文件的读写

python中简单的文件读写案例

fo = open('1.txt','r')
print('文件名：%s'%fo.name)
print('是否关闭：%s'%fo.closed)
print('访问模式：%s'%fo.mode)
print('内容：%s'%fo.read())

也可以通过

with open('2.txt','w',encoding='utf8') as f:
    f.write('尝试写入中文字符')

来写入新的文件

python pow函数

在python 3 中，pow函数存在于math包中；用于求特定数字的次方数；其中第一个参数是底数，第二个参数是次数

import math
print(pow(100,2))

最后输出的结果为：10000

创建 range序列

range只有一个参数的时候，创建一个：从0开始，直到（参数-1）的序列
range 有两个参数的时候，创建一个从第一个参数的数值起 到（第二个参数的数值-1）为止的序列
range 的第三个参数指的是每次跨度的步长
range返回的是一个range对象；这个range对象可以转换成list对象并被输出

print(list(range(11)))

输出的结果是：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range通常在循环语句中使用，也可以与enumerate连用，给对应的数字匹配序号

for i in range(1,11):
    print(i)

用这种方式可以控制循环的次数；最后输出了

1
2
3
4
5
6
7
8
9
10

也就是说这个循环执行了10次

python enumerate函数

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
enumerate()函数的第一个参数为可迭代对象，第二个参数为索引的初始值
一般在一个for循环中for v,i的v代表的是序号，其中i代表的是可迭代对象中的元素

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
for v,i in enumerate(seasons,1):
    print(v,i)

最后输出的结果为：

1 Spring
2 Summer
3 Fall
4 Winter

python 反向迭代器

reverse 函数，可以把参数里的集合反向输出

rev = reversed([1,2,3,4,5,6])
print(rev)
print(type(rev))
print(list(rev))

reversed函数会返回一个list_reverseiterator迭代器对象，这个对象可以转换成列表也可以被遍历

for i in reversed([1,2,3,4,5,6]):
    print(i)

最后的输出结果是：

6
5
4
3
2
1

python round()函数

这个函数有两个函数，常用于对参数护着结果进行四舍五入的取舍运算
四舍五入;round 函数的第一个参数是需要四舍五入的浮点数值，第二个参数是保留的小数位数
当只有一个参数的时候函数默认为保留到整数位

print(round(1.414))
print(round(2.22535,1))

第一条语句的输出结果是：1；
第二条语句的输出结果是：2.2

python set()函数

这个函数的作用是将数据集合转换成集合的形式（就是使用{}包围的数据集）参数是需要转换的数据集合
对于列表和元组都适用

lst = [1,2,3,4,5,6,7]
lst_ = set(lst)
print(lst_)
lst = (1,2,3,4,5,6)
lst_ = set(lst)
print(lst_)

输出的结果分别是：
{1，2，3，4，5，6，7}
和{1，2，3，4，5，6}

python 使用切片对象slice()

切片对象函数slice()有三个参数
第一个参数是切片起始的元素下标（包括这个元素）
第二个参数是切片终止下标（不包括这个元素）
第三个参数是步长（两个元素之间的距离）步长：参数可选
调用这个函数会返回一个不可迭代的slice对象（遍历或者试图转换为列表都会导致报错）

a = [1,2,3,4,5,6]
a1 = slice(0,5)
print(a[a1])
print(type(a1))

输出的结果为：

[1, 2, 3, 4, 5]
<class 'slice'>

正确的使用方法是将其放入数据集合的索引[]中（作为一种切片方式进行调用，常用于列表切片）

from random import randint
cake = [randint(1,100) for _ in range(1,100)]   # 随机生成100个处在0到100之间的整数 在循环语句中使用 _ 作为一个变量仅起到控制循环次数的作用
print(cake)
perfect_cake_slice = slice(0,10,2)
print(cake[perfect_cake_slice])

输出的结果为：

随机生成的整数序列
[21, 93, 18, 67, 65, 93, 70, 10, 81, 93, 57, 38, 85, 22, 24, 20, 23, 60, 37, 79, 59, 94, 35, 36, 30, 15, 82, 77, 4, 18, 30, 47, 3, 11, 83, 14, 37, 85, 8, 88, 15, 49, 35, 49, 63, 81, 8, 71, 86, 1, 41, 30, 86, 58, 52, 38, 64, 55, 4, 61, 76, 45, 46, 30, 51, 94, 54, 76, 62, 96, 23, 92, 74, 24, 87, 26, 24, 65, 32, 3, 2, 49, 86, 84, 5, 98, 98, 97, 28, 67, 89, 1, 1, 91, 82, 15, 60, 74, 96]
切片之后的整数序列
[21, 18, 65, 70, 81]在这个序列中包含下标为0的元素但是不包含下标为10的元素

同样的倒序切片也适用；在倒序切片的使用情况下，第一个参数是从后往前切片的起始元素的下标（包括这个元素），第二个参数是倒序切片停止的元素下标（不包括这个元素），第三个参数（可选）指的是切片的步长，因为是倒序所以第三个参数是负数；步长的数值大小是第三个参数的绝对值

rev_cake_slice = slice(10,0,-2)   # 倒序切片，包含了元素下标是10的元素却不包含元素下标是0的元素
print(cake[rev_cake_slice])   

其他的切片方法

可以直接使用列表切片的方法

list[起始下标（包括元素）:停止下标（不包括元素）:步长（可以省略）]
a = [1,3,5,7,9,0,3,5,7]
print(a[::-1])   # 对列表进行倒序排序
print(a[8:5:-2])  # 列表从后往前（这里是指从最后一个元素往前）切片
print(a[:6:-1])  # 切取最后两个元素（下标是7和8）

python排序函数 sorted()

sorted 可以把集合顺序或者倒序排列，其中命名参数reverse表示是否开启倒序（默认顺序是从小到大排列）

a = [88,55,66,11,44,89,77,54,47,85,82,11]
a_ = sorted(a,reverse=False)
print(a_)
b = sorted(a,reverse=True)
print(b)
# 输出的结果是：[11, 11, 44, 47, 54, 55, 66, 77, 82, 85, 88, 89]（正序）
# [89, 88, 85, 82, 77, 66, 55, 54, 47, 44, 11, 11]（倒序）

也可以使用lambda设定序列中或者字典中的某个参数，利用这个参数的数值进行排序；（使用命名参数key，结合匿名函数lambda 确定在多个键值对中排序的参照参数）

list = [{'name':'martin','age':22,'gender':'male'},
        {'name':'kathrine','age':21,'gender':'female'}]
list = sorted(list,key=lambda x:x['age'],reverse=False)   # 通过 key 的参数设定的值进行判断
print(list)
# 输出的结果为：[{'name': 'kathrine', 'age': 21, 'gender': 'female'}, {'name': 'martin', 'age': 22, 'gender': 'male'}]

python tuple函数

将数据集合转换为元组类型
这种转换对于列表和数组都适用，把一种类型的数据集合转变为元组类型的数据集合
也就是把一个非元组的对象，转换成一个元组对象

lst = [1,2,3,4,5,6,7]
collect = {1,2,3,4,5,6,7}
lst = tuple(lst)
collect = tuple(collect)
print(lst,collect)
print(type(lst))
# 最终的输出结果为
# (1, 2, 3, 4, 5, 6, 7) (1, 2, 3, 4, 5, 6, 7)
# <class 'tuple'>

python zip() 函数

zip()函数是python的聚合迭代器函数，功能是把两个元素对应下标的元素捆绑输出
可以通过遍历输出，也可以通过列表推导式输出
下面是一种最常用的遍历输出的方式，其中x列表代表序号（或者名称）y列表代表值在for循环中v,i的位置于zip参数中x,y两个可迭代对象的位置是一致的决定了输出顺序：也就是，先输出x集合里的v，再输出y集合里的i

x = [1,2,3]
y = ['a','b','c']
for v,i in zip(x,y):
    print(v,i)
# 输出结果：
# 1 a
# 2 b
# 3 c

还有一种使用zip函数的方式是通过列表推导式
列表推导式的格式：
[输出对象的形式 for x,y（两个输出对象）in zip（输出对象对应的两个可迭代对象）]
列条推导式最后会返回一个list对象

a = range(5)
b = ['a', 'b', 'c', 'd', 'e']
ll = [str(x) + str(y) for x, y in zip(a, b)]
print(ll)

global 表示将变量声明为全局变量
nonlocal 表示将变量声明为外层变量（外层函数的局部变量，而且不能是全局变量）
python引用变量的顺序如下：
1、当前作用域局部变量
2、外层作用域变量
3、当前模块中的全局变量
4、python内置变量
即优先从局部作用域中查找这个变量，如果没有的话，再去外层找，如果到了最后还没找到，则报错。
python 在新建一个变量时，默认作用域为当前局部作用域。

a = 1
def fun():
    print(a)
fun()
# 最后的输出结果是 1 因为在python中函数会向外层查找变量的值
def fun():
    a = 2
    print(a)
fun()
# 最后的输出结果是 2 因为函数内部定义了这个变量
def fun():
    print(a)
    a = 2
fun()
# 会报错UnboundLocalError: local variable 'a' referenced before assignment
# 也就是说在python查找局部变量（函数内部）的时候找到了 a 但是局部变量 a 在定义之前就引用了。
# 这说明在 print(a) 之前，python 已经知道了 a 是一个局部变量，只能从局部作用域中查找。从哪里知道的？ 从 a = 2 这一行知道的。
def fun():
    global a
    print(a)
    a = 2
fun()
print(a)
# 想强制访问 a 的值
# 最后的输出结果是 2 
# 在使用 global 关键字之后 a 变成了一个全局变量 所以函数内部对 a 的值的修改作用于全局（出了作用域，仍然有效）

nonlocal 表示外层变量，功能是让内层函数访问和修改外层函数变量的值；但是一旦外层变量是全局变量，则只能用 global

def outfun():
    a = 1
    def fun():
        nonlocal a    # 这里的nonlocal关键字表示先使用外层变量 a
        print(a)
        a = 2     # 在函数 a 被指定为外层变量之后，可以通过修改函数内的值从而修改外层函数的值（指向的是同一块内存空间）
    fun()
    print(a)   # 这里输出的 a 是经过nonlocal关键字在函数内部修改之后的值
outfun()

在使用 nonlocal a 之前，必须保证外层的确已经定义过 a 了，但是在 global a 的时候，可以允许全局变量中还没有定义过a，可以留在后面定义。

def outer_fun():
    a = 1
    def fun():
        global a
        a = 3
        print(a)   # 第一次输出的是全局变量 a 的值，此时全局变量的值被修改为3
        a = 2   # 在函数内修改的是全局变量的值，此时全局变量 a = 2
    fun()
    print(a)   # 这里的输出结果是 1 因为函数优先调用了自己的内部变量
outer_fun()
print(a)

建议永远将 global 或者 nonlocal 声明放在取值/赋值的最前面
只要在一个作用域中有 global 或者 nonlocal 命令，则不管这个命令在哪个位置，在整个作用域的开始到结尾都是有效的。
如将刚才例子的 global a 和 a = 3 互换位置，结果是一模一样的：

python 链式比较

就是将几个变量（或者数值常量）连起来比较；如果结果为真，返回true；如果结果为假返回false

i = 3
print(0<i<9)   # 返回True
print(1<i<2)   # 返回false

python 不用if-else语句实现计算器

将对应operator包中的关于数字计算的方法，以键值对的形式封装在字典中，然后将对应的运算数添加到最后进行说明；再利用指定对象调用指定关键字的时候，会从字典提供的键值对中找到对应的方法，调用方法并将函数中的变量作为参数传递到对应的方法中

from operator import *
def calculator(a,b,k):
    return {
        '+':add,
        '-':sub,
        '*':mul,
        '/':truediv
    }[k](a,b)
print(calculator(1,2,'-'))    # 运算：1-2；输出-1 
print(calculator(4,8,'*'))    # 运算：4*8；输出：32

python链式操作案例

链式操作案例语法，return（首先在第一个括号中写if语句选择表达式的那种，针对的变量是函数参数里的可选择参数（理解成使用的方法））（在第二个括号里写上自己录入的参数，可以理解成第一个括号选择方法，第二个括号给出方法的参数）

from operator import add,sub
def add_or_sub(a,b,oper):
    return (add if oper == '+' else sub)(a,b)
print(add_or_sub(11,12,'+'))

交换两元素案例

简单来说定义一个函数，然后将函数参数的位置互换，从而在输出的时候达到值交换的目的

def swap(a, b):
    return b, a
print(swap(0, 5))

去最值求平均

这个案例的关键在于列表的截取，先通过sorted函数对列表内的数值进行排序，然后通过列表切片的方法截取第二个元素到最后一个元素组成一个新的列表，最后求新列表的平均值就可以了

def score_mean(lst):
    lst = sorted(lst)   # 先对列表进行从小到大的排序
    lst2 = lst[1:len(lst)-1]   # 去掉一个最大值，去掉一个最小值
    return round(sum(lst2) / len(lst2),1)
lst = [9.1, 9.0, 8.8, 8.6, 19, 8.7, 8.2, 9.0]
print(score_mean(lst))

打印九九乘法表

这是一个老生常谈的例子，重点在于确定行数和列数；以及在循环中，确定行数（i）和列数（j）的取值范围
行数（i）的取值范围是 1--9；列数（j）的取值范围是（1--i）每次循环结束（外层循环代表一行）需要打印换行

for i in range(1,10):
    for j in range(1,i+1):
        print('%d * %d = %d'%(i,j,i*j),end='\t')
    print()

python 列表等分

将一个列表分为若干个长度相等的列表；
这个函数的关键在于列表切片中的参数变量是由后面的循环语句决定的；i代表的是切片的次数；两次切片之间的长度就是这个列表的长度；切片的次数由总长度/新列表的长度决定
ceil()函数的意思是向上取整

from math import ceil


def divide(lst, size):
    if size <= 0:
        return lst
    return [lst[i * size:(i + 1) * size] for i in range(0, ceil(len(lst) / size))]
r = divide([1, 3, 5, 7, 9], 2)
print(r)
r = divide([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 3)
print(r)
r = divide([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0)
print(r)
r = divide([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], -3)
print(r)

使用filter函数除去列表里的空元素

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。filter()接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False;
在这个案例中，我们把结果返回true的元素放到一个新的列表中并返回，就形成了一个新的列表

def filter_false(lst):
    return list(filter(bool,lst))

f = filter_false([None, 0, [], '', 'ok', [1, 2]])
print(f)

比较较长的列表

使用可变位置参数接收多个列表（实参后用元组的形式接收多个未命名参数）
并将这个参数集合（也就是每个列表）传递到比较大小的max方法中，max方法使用lambda匿名函数将比较的标准设定为列表的长度大小

def max_length(*lst):
    return max(*lst, key=lambda v: len(v))  # 将第一个参数（数据集合）里的每一个数字都赋值给匿名函数，获取每个列表的长度，最后通过max函数选出长度最大的列表

r = max_length([1, 2, 3], [4, 5, 6, 98], [7, 8])
print(f'更长的列表{r}'.format(r))

使用匿名函数确定排序或者筛选的字段
　key=lambda y: 方法 备注：这里y可以是任意字母，等同key=lambda v:方法
相当于对lambda函数的参数传入了之前可迭代对象的每个参数

求众数（在一个列表中出现次数最多的元素）

这个比较的参数是在一个列表中个元素出现的次数；
解决的方法是，将在一个元素在列表中出现的次数，作为一个匿名函数传入方法max中（返回一个函数对象）
匿名函数：key = lambda x:lst.count(x)

def top1(lst):
    return max(lst,default=None,key=lambda x:lst.count(x))
print(top1(lst = [1, 3, 3, 2, 1, 1, 2]))

求多个列表中最大的数

使用max方法的三层嵌套，最内层的：在lambda函数内的max负责筛选出每个列表中最大的元素
中间层max负责比较元素值最大的列表，最外层max比较的是元素值最大的列表中的最大的元素，也就是所有列表中最大的元素

def max_lists(*lst):
    return max(max(lst, key=lambda x: max(x)))

r = max_lists([1, 2, 3], [6, 7, 8], [4, 5])
print(f'最大的元素是{r}')

列表查重（判断是否有重复元素）

使用set函数：set()参数是列表的时候会自动的删掉重复的元素，并返回一个新的列表；这个方法的判定条件：如果返回的列表长度于原列表相同，那么返回true（没有重复元素）否则返回false（有重复元素）

def has_duplicate(lst):
    return len(lst) == len(set(lst))
x = [1, 1, 2, 2, 3, 2, 3, 4, 5, 6]
y = [1, 2, 3, 4, 5]
print(has_duplicate(x))
print(has_duplicate(y))

列表反转

用列表切片list[::-1]的方式反转列表（并封装在函数中）

def reverse(lst):
    return lst[::-1]
r = reverse([1, -2, 3, 4, 1, 2])
print(r)

生成等差数列

实现生成一个等差数列，并用列表的方式返回
重点在于确定首部和公差，求出公差（也就是步长step），并用未添加进列表的数字总个数（n）控制循环
每次循环都将新生成的数字start+step加入列表，并让 n-1

def rang(start, stop, n):
    # 将所有参数确定为保留两位有效数字的形式
    start, stop, n = float('%.2f' % start), float('%.2f' % stop), float('%.2f' % n)
    # 确定公差
    step = (stop - start) / n
    # 创建一个新的只有首部的列表（方便添加元素组成等差数列）
    lst = [start]
    while n > 0:
        start, n = start + step, n - 1   # 每进行一次循环，数组中新增一个元素，总个数-1（用来控制循环）
        lst.append(round(start,2))   # 将结果保留两位小数之后加入等差列表
    return lst
print(rang(1, 8, 10))

按条件分组

对列表中的元素进行按条件分组，并返回一个新的列表，函数的第一个参数是列表，第二个参数是分组的函数对象（案例中使用的 是匿名函数进行调用）
遍历这个列表，将符合f条件的参数放到一个列表中，再次遍历原列表，将不符合条件的列表放到新的列表中，并作为一个列表返回

def bif_by(lst,f):
    return [[x for x in lst if f(x)],[x for x in lst if not f(x)]]
print(bif_by([77,55,66,41,22,55,33,10,2,3,4],lambda x:x>33))