前言
python的基础语法：https://blog.youkuaiyun.com/qq_38175040/article/details/106217783
1.循环
for i in range(100)： 默认从0开始且每次加1，直到99结束
for i in range(1,11,2): 从1开始，每次加2，到9结束
for i in range(1,1): 这个循环一次都不执行
while True: 构建死循环用while
nums = [0,1,2,3,4,5,6,7,8,9] for循环的对象也可为一个集合（列表，字典等）
for num in nums:
print(num)
在循环的过程中，尽量不要对对象进行增删操作，否则可能导致循环达不到效果
如下，在循环的过程中删除元素，导致2没有被打印(不过逆序遍历列表并在过程中不断pop，删除最后一个元素是可行的)
>>> a= [1,2,3]
>>> for i in a:
print(i)
if i == 1:
a.remove(i)
1
3
如果要在循环的过程中对列表的内容进行修改，使用for i in range(len(a)),不能用for i in a
2.列表
a = [] 定义一个空列表
a.sort() 排序(元素全为数字)，时间复杂度为（nlogn）
a.append(1) 向列表内添加整数元素
a.append('fwefew') 向列表内添加字符串元素
a.extend(b) b可能为字符串，列表，元组等，拼接到a的后面
a.pop(0) 删除a[0]这个元素
a.pop() 移除最后一个元素并返回该值
a.remove('a') 移除列表内的第一个匹配项
array = [0]*10 定义一个常数级别的空间
[[-1,-1,2],[-1,0,1]] 列表里的数据项可以各不相同，例如[1,'A',[1,2,3]],而这里的格式不过是列表里储存的数据项都是列表而已
a.count(1) 查找列表里1这个元素的出现次数
a = nums.insert(3,'zhang') 在列表里的对应位置插入'zhang'
a[-1],a[-2] 分别指倒数第一个，倒数第二个元素
a.index('z') 返回元素z的下标
set(a) 剔除重复元素,剩下的其余元素生成一个集合，集合无序，不重复
list(set(a)) 将集合数据类型转换为列表
sorted函数：
foo = [{"name":"derek","age":19},{"name":"wang","age":54},{"name":"li","age":17},{"name":"xx","age":23}]
print(sorted(foo,key=lambda s:s['age'])) 根据age的值排序
# 根据列表内元素的首元素对列表进行排序
a.sort(key = lambda x:x[0])
3.集合
集合 是一个无序的，不重复的元素序列 ，不能通过索引取值和进行分片操作
a = set() 创建一个空的集合，a = {}是创建一个空的字典
a.update('abcd') 向其中添加元素
或者
b = 'abcd'
for i in b:
a.add(i)
>>> new_set = {_ for _ in 'abcd'}
>>> print(new_set)
{'b', 'c', 'd', 'a'}
统计一个字符串中每个字符出现的次数：
dic={i:str1.count(i) for i in set(str1)}
4.字符串
字符串是不可变的，不可更改其中的元素，str[1] = a 会报错
len(s) 字符串s的长度
ord('1') 查出1的ASCII码值，即使1是整数ord里也要加''
ord(s[i]) 查找字符串中第i+1位的字符的ACSCII码值，不用加''
str_a = '' 定义一个空字符串
str_a = str_a + s 将字符串s拼接到str_a后面
a.replace('o','a',1) 将字符串里的o替换成a，替换一次
拼接而后打印：
print(" hello %s, you are %d " %('aa', 10))
print("hello {name},you are {age}".format(name='aa',age=10)) 通过key
list = ['aa',10]
print("hello {a[0]},you are {a[1]}".format(a=list)) 通过列表
d = {'name':'aa', 'age':10}
print("hello {m[name]},you are {m[age]}".format(m=d)) 通过字典
str.split() 将字符串按空格切分开，并把单词全部存入一个列表中
str.split('$',1) 遇到$符号切割，切割一次
'$'.join(list_01) 将list_01中的每个单位以$为间隔,拼接成一个字符串
将一个英文语句以单词为单位 逆序排放 'I am a boy' ---> 'boy a am I'
print(' '.join('i am a boy'.split()[::-1]))
更多字符串的内置函数：
字符串修饰：
center 字符串在指定长度居中，默认以空格填充，也可以指定字符填充
ljust 字符串在指定长度左对齐，默认以空格填充，也可以指定字符填充
rjust 字符串在指定长度右对齐，默认以空格填充，也可以指定字符填充
zfill 将字符串填充到指定的长度，不足的地方用0从左开始补充
format 按照顺序，将后面的参数传给前面的大括号，用于print()
strip 默认去除字符串两边的空格，去除的内容也可指定
lstrip 默认去除字符串左边的空格，去除的内容也可指定
rstrip 默认去除字符串右边的空格，去除的内容也可指定
字符串大小写转换：
upper 将字符串中所有字母转换为大写
lower 将字符串中所有字母转换为小写
swapcase 将字符串中所有字母大小写互换
title 将字符串中的单词首字母大写，其他字母小写
capitalize将字符串的首字母大写
字符串的判定：
isalnum 判断字符串是否完全由数字和字母组成
isalpha 判断字符串是否完全由字母组成
isdigit 判断字符串是否完全由数字组成
isupper 判断字符串是否完全是大写
islower 判断字符串是否完全是小写
isspace 判断字符串是否完全由空格组成
startswith 判断字符串的开头字符，可以截取判断
endswith 判断字符串的结尾字符，可以截取判断
5.1 特殊写法
INT_MAX = 2 ** 31 2的31次方
5/2 = 2.5
5//2 = 2 #向下取整，-5//2结果为-3
if a in arrow: 判断元素a是否在对象arrow中，arrow可能为字符串，列表，字典等
type(value) 返回的是value的数据类型
d = x if a > b else y
d ={'True':x, 'False':y}[a>b]
def func(x):
return x**2
print([func(x) for x in a ]) #列表递推式
a = [x for x in li if x%3==0] #列表递推式
x,y,z = 1,2,3 多个数同时被赋值
x,y = y,x x,y互换值，并不像C语言中需要一个中间变量
5.2 特殊语法
将一个英文语句以单词为单位 逆序排放 'I am a boy' ---> 'boy a am I'
print(' '.join('i am a boy'.split()[::-1]))
统计一个字符串中每个字符出现的次数：
dic={i:str1.count(i) for i in set(str1)}
6.创建二维数组
>>> a = [[0]*6 for i in range(3)]
>>> print(a)
[[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
本质其实就是一个列表，其内的元素也都是列表而已。
7.切片
[start:end:step] 切片的标准格式，步长如果是正数 ，从左往右 ，如果是负数 从右往左取数
a[0:4] 或者 a[:4] 切取a[0],a[1],a[2],a[3],左闭右开,start若为0，可省略
a[5:] 切取a[5]至最后一个元素，不是倒数第二个元素
a[:] 切取全部a
利用切片在某个位置插入或者替换元素：
>>> a = ['a','b','c','d','e','f','g','h','i','j','k']
a[3:3] = [1,2,3]
>>> print(a[3:3]) a[3:3]截取为空，代表用[1,2,3]替换[],也就是在列表a[3]之后插入1，2，3这三个元素
[]
>>> print(a)
['a', 'b', 'c', 1, 2, 3, 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']
>>> a = ['a','b','c','d','e','f','g','h','i','j','k']
>>> a[3:5] = [1,2,3,4] 与上面不同，a[3,5] 截取a[3],a[4]这两个元素，代表用[1,2,3,4]替换[d,e]
>>> print(a)
['a', 'b', 'c', 1, 2, 3, 4, 'f', 'g', 'h', 'i', 'j', 'k']
8.字典
python的字典放在算法里可以视为哈希表，即查询if a in dict(dict是字典)的时间复杂度为O(1)
但if a in list(list为列表)的时间复杂度为O(n)
>>> items = [('name','zhang'),('age',2)] 通过dict函数创建字典
>>> d = dict(items)
>>> d
{'age': 2, 'name': 'zhang'}
>>> d = dict(name ="zhang",age=2)
>>> d
{'age': 2, 'name': 'zhang'}
a.keys() 返回a中所有键
for key in a: 遍历a中所有的键
for value in a.values() 遍历a中所有的值
d.get('a') 访问键a，如不存在返回None，不会报错
字典的排序（字典是一个无序的数据结构，一般都不对其进行排序的）：
>>> dict_01 = {1:2,3:5,-1:5}
>>>> sorted(dict_01) #我们可以用sorted函数，根据其键排序并返回键所组成的列表
[-1, 1, 3]
>>> sorted(dict_01.values()) #也可以根据值来排序
[2, 5, 5]
也可以用如下方法将字典根据值来排序
d={'a':1,'c':3,'b':2} # 首先建一个字典d
#d.items()返回的是： dict_items([('a', 1), ('c', 3), ('b', 2)])
d_order=sorted(d.items(),key=lambda x:x[1],reverse=False) # 按字典集合中，每一个元组的第二个元素排列。
# x相当于字典集合中遍历出来的一个元组。
print(d_order) # 得到: [('a', 1), ('b', 2), ('c', 3)]
字典的删除：
>>> dict_01 = {1:3,2:4,4:7}
>>> dict_01.pop(4) #用pop加传入的键，删除相应的键值对
7
>>> dict_01
{1: 3, 2: 4}
>>> dict_01.clear() #clear清空字典的所有内容
>>> dict_01
{}
字典是无序的，如下的情况在哈希表中可能用的较多：
>>> a = {1:3,2:4}
>>> b={2:4,1:3}
>>> a == b
True
9.1函数
def calc_demo(*numbers): *number代表传入的参数数目可以不固定
>>> def print_person(name,male,**kwargs): **kwargs代表传入的参数是字典
print('name is {}, sexy is {},'.format(name, male), 'other:', kwargs)
>>> print_person('wang','F',age=10, address='shanghai')
name is wang, sexy is F, other: {'age': 10, 'address': 'shanghai'}
def add(x):
return x + 1
a = add 函数可以作为变量，传递给另一个变量
def get_add(f): 函数可以作为参数，也可以作为返回值
return add
9.2 匿名函数lambda
如果一个函数的功能很简单，那我们不一定非要特意去定义他。
a = 3
b = 4
c = lambda a,b: print('a大') if a>b else print('b大') # ':'号前的a，b两个数就相当于形参传给函数，':'号后调用这两个数
c(a,b) #上面的lambda仅仅相当于创建了一个函数，这里调用他一下
list_02 = [(lambda x:x+1)(x) for x in a if x%3==0] #(lambda x:x+1)定义函数，(x)调用这个函数
>>> list(map(square, [1,2,3,4,5])) # map函数根据提供的函数square对指定的序列[1,2,3,4,5]做映射
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
10.1 内置方法(例)
.count('a') 计算字符串或者列表中字符a出现的次数
>>> str = 'china wall'
>>> str.title() 将字符串中每个首字母大写
'China Wall'
a = '#'
a.join(exa) 以a为分隔符，将exa中的所有元素分隔开，生成一个新的字符串，exa可能为字符串，列表，字典等
>>> seq1 = ['hello','good','boy','doiido']
>>>> print ' '.join(seq1)
hello good boy doiido
copy函数：
copy对于一个复杂对象的子对象(比如说序列里嵌套序列，字典里嵌套序列)并不会完全复制。
对于copy产生的子对象，会把它当做一个公共镜像存起来，所有对他的复制都被当做一个引用。
>>> d = {'name': 'derek', 'age': 12} 对一个简单对象的copy
>>> c = d.copy()
>>> c['age'] =20
>>> print(c)
{'name': 'derek', 'age': 20}
>>> print(d)
{'name': 'derek', 'age': 12}
>>> d = {'name':['derek','wang']} 对一个复杂对象的copy，修改copy的c，但源d的复杂子对象也被修改了（使用deepcopy不会这样）
>>> c = d.copy()
>>> c['name'].append('li')
>>> print(d['name'])
['derek', 'wang', 'li']
map()方法见9.2匿名函数
filter(func, iter) #返回一个遍历序列中满足指定条件的元素的迭代器
li = [1,3,11,12,9]
def func_3(x):
if x %3 ==0:
return True
else:
return False
a = list(filter(func_3,li))
a = list(filter(lambda x: x%3==0, li))
10.2 内置方法（链接）
sorted函数：https://www.runoob.com/python/python-func-sorted.html
11.闭包
闭包： 由函数及其相关的引用环境组合而成的实体
如果在一个内部函数里，存在对外部作用域(但不是全局作用域)的变量进行引用，那么，这个内部函数就是闭包
1. 函数内部定义函数
2. 内部函数必须有对encloseing作用域的引用(encloseing作用域:函数内部与内嵌函数之间)
def outer():
def inner(): 此处inner不是闭包，是函数内部定义的函数，但未对enclosing作用域的值进行引用。
print("inner func excuted")
inner()
print("outer func excuted")
outer()
def outer():
x = 1
def inner(): 此处的inner是闭包，是函数内部定义的函数且对enclosing值x进行了引用。
print("x=%s" %x)
print("inner func excuted")
inner()
print("outer func excuted")
outer()
12.异常
try:
x = int(input("the first Num: "))
y = int(input("the second Num: "))
print (x/y)
except (ZeroDivisionError,TypeError) as e:
print(type(e))
else:
print('未触发异常')
finally:
print('不管是否出发异常都会执行finally')
知道一些常用异常有助于快速查找自己代码中的错误：
Exception 所有异常的基类
AttributeError 特性引用或赋值失败时触发
IOError 试图打开不存在文件时触发
IndexError 使用序列中不存在的索引时触发
KeyError 使用映射中不存在的键时触发
NameError 在找不到名字（变量）时触发
SyntaxError 在代码形式错误的时候触发
TypeError 在内建操作或者函数应用于错误类型的对象时触发
ValueError 在内建操作或者函数应用于正确的对象，但该对象使用不合适的值时触发
ZeroDivisionError 除以0
13.包，模块，库
os 库提供通⽤的、基本的操作系统交互功能
getcwd() 获得当前⼯作⽬录，即当前 Python 脚本⼯作的⽬录路径。
mkdir('dirname') 在当前路径下，建⽴⼀个⼦⽂件夹。注意：⽂件已存在时会报错。
rmdir('dirname') 删除⼀个⽂件夹，不存在时会报错
listdir() 列出某⽬录下所有的⽬录和⽂件
rename() 修改路径下⽂件的名字
remove('test.py') 删除⽂件,要加后缀名
chdir() 修改当前⽬录
os.path.abspath(path) 返回path在当前系统中的绝对路
os.path.join(path,*paths) 组合path和paths，返回⼀个字符串
os.path.exists(path) 判断path对应⽂件或⽬录是否存在，返回布尔类型
os.path.isfile(path) 判断path所对应的是否是已存在的⽂件，返回布尔类型
os.path.isdir(path) 判断path所对应的是否是已存在的⽬录，返回布尔类型
time库可以获得当前时间，操作时间和⽇期，从字符串读取时间以及格式化时间为字符串：
asctime([tuple]) 将时间元祖转化成字符串
localtime([secs]) 将秒数转化成⽇期元祖，以本地时间为准
mktime([tuple]) 将时间元祖转化成本地时间
sleep(secs) 休眠 secs 秒
strptime(string[,format]) 将字符串转化成时间元祖
time() 当前时间
random 模块报货返回随机数的函数，可以⽤于模拟或者⽤于任何产⽣随机输出的程序
random() 返回 0 < n <=1之间的随机实数
getranbits(n) 以⻓整型形式返回n个随机为
uniform(a,b) 返回随机实数n，其中 a<=n < b
randrange([start],stop,[step]) 返回range(start,stop,setp) 中的随机数
choice(seq) 从序列seq 中返回任意元素
shuffle(seq[,random]) 原地指定序列seq
sample(seq,n) 从序列seq 中选择N个随机且独⽴的元素
14.文件操作
写⼊
>>> f = open(r'D:\a.txt','w')
>>> f.write('hello')
>>> f.write('world')
>>> f.close()
或者使用 with open(xxxx) as f: 来打开文件
读
>>> f = open(r'D:\a.txt','r') # 'r' 可以省略
带参数n 是按字节处理
>>> f.read(4)
'hell'
>>> f.read()
'oworld'
file.readlines() 读取⼀个⽂件的所有⾏，.readline()代表读取单行
15. if name == ‘main’:
一个python文件通常有两种使用方法，第一是作为脚本直接执行，第二是 import 到其他的 python 脚本中被调用（模块重用）执行。因此 if name == ‘main’: 的作用就是控制这两种情况执行代码的过程，在 if name == ‘main’: 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而 import 到其他脚本中是不会被执行的。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
