一、标识符命名规范
1.标识符为数字，字母，下划线，中的一种或几种的组合（数字不能开头）
2.大小写敏感
3.不能使用关键字，保留字 is、if、not、print等
4.标识符理论上是没有长度限制的
通常习惯：
1）.望文生义
2）.常量全大写
3）.包名全小写
4）.变量名第一个单词首字母小写，后面单词首字母大写
5）.类名第一个单词首字母大写，后面单词首字母大写（驼峰命名法）
二、变量 (弱类型)
1.a=10,在python中a相当于一个标签，贴在了10上面。（实际存储的是10的首地址）
2.符合标识符命名规范
3.先定义，后使用。
三、数据类型
1.整形 int 整数
2.浮点型 float 小数
3.字符串 str 这里注意要用引号，引号成对出现，可以用单引号，双引号，三引号
“let's go” 跨行时要用三引号
4.列表 list
5.元组 tuple
6.字典 dict
7.集合 set
8.复数 aj+b
9.布尔 bool True False
四、数据类型的转换
1.字符串转整型
int()(工厂函数) 本身是可以转换成整型的
2.字符串转浮点型
float() 本身是可以转换成浮点型的
3.浮点型转整型
int()
4.整型转浮点型
float()
5.整型转为字符串
str()
6.浮点型转为字符串
str()
int() float() str() list() tuple() 内置函数，工厂函数
7.int()按四舍五入强转 int(a+0.5)
五、数据类型的确认
1.type()
type(所要确认的数据)
2.isinstance()
isinstance(所要确认的数据，数据类型)
a=3 isinstance(a,int) 返回一个布尔值
六、运算符
1.一般运算符
+，-，*，/，//，%，**
当使用除法的时候，会自动升级整型数据为浮点型。
// 地板除
% 取模
** （2**3==8 8**(1/3)==2.0）
2.布尔运算
<,>,=,<=,>=,==,!=
返回值 True or Flase 的布尔值
3.逻辑运算符
and,or,not
优先级：not>and>or
x or y x真则取x,x假则取y
x and y x真则取y,x假则取x
七、优先顺序
1.括号()
2.**
3.*，/（从左往右）
4.+，-
八、条件分支流程
1.if条件分支 5<num<10 等价于 num>5 and num<10
语法：
1）if 布尔表达式：
代码
2）if 布尔表达式：
代码
else:
代码
3）if 布尔表达式：
代码
elif 布尔表达式：
代码
elif 布尔表达式：
代码
elif 布尔表达式：
代码
else:
代码
4）elif当条件达成会跳出分支流程，用if则会继续执行
2.if else的嵌套使用
if 表达式：
if 表达式：
代码
else:
代码
else:
代码
注意：在python中同一级的if,else必须对齐；并不遵守就近原则，也避免了else悬挂问题
九、三元操作符
求x,y,z中最小的数，x=3,y=4,z=5
例：
x,y,z=4,3,5
small=(x if x < y else y)
small=(small if small<z else z)
print(small)
错： x,y,z=4,3,5
small=(x if x < y else (y if y<z else z))
print(small)
十、循环流程
1.while循环
语法：while 布尔表达式（或者循环停止条件）：
循环体
循环停止条件(注意要给循环设立一个条件，避免死循环)
2.for循环
语法：for 变量 in 可迭代对象：
循环体
可迭代对象：列表，元组，字符串，字典，集合
1.range(start,stop,step) [satrt,stop) start可以取到，stop取不到，step代表步长
2.通常情况下，start,step默认为0，1是可以省略的
3.例：
for i range(10):
print(i,end='')
for i range(10,0,-1):
print(i,end='')
3.break
终止循环
4.continue
跳出循环
十一、列表list
1.列表的创建
1）创建一个空列表 l=[]
2）创建一个非空列表 l=[1,2,3]
3）创建一个混合列表 l=[10,"hello",[1,a,b],{"name":"zhang"}]
2.添加元素
1）append（元素）
在列表中追加一个元素
用"."的方式调用
2）insert（索引，元素）
在索引处添加一个元素
3）extend（可迭代对象）
可迭代对象：元祖、字符串、列表、range()
3.删除元素
l）.clear()
清空列表元素
2）.remove(3)
删除第一个出现的（3）元素
3）.del
del 列表名，删除的是列表名这个变量，并没有删除原来的列表
4）.pop(下标)
弹栈。栈，后进先出，先进后出
pop默认弹出最后一个元素
如果我们想指定弹出某个元素，要给出下标
4.访问
1）通过下标访问
形式：列表名[下表]
2）用for循环遍历
for i in [1,2,3,4]
print(i)
5.分片
切片：slice6
1）列表名[起始下标:终止下标] 注:终止下标取不到
2）如果起始下标是0，那么起始下标可以省略不写
例：
l[1,2,3,4]
l[:2] [1,2]
3）如果终止下标是到列表末尾，那么终止下标可以省略不写
4）如果起始下标、终止下标都没写，相当于拷贝了一份列表
6.分片的进阶
1）l[起始下标:终止下标，步长]
下标可以是负的，列表末尾的下表是-1.步长也可以是负的
7.二维列表
1）二维列表就是列表中包含列表
2）二维列表的创建，直接创建
l=[[],[]]
3）二维列表的访问
a.下标访问
例：>>> li=[[1,3,4],["hai"]]
>>> li[0][0]
1
b.for循环遍历访问：
①.访问所有，用for循环嵌套遍历
例：for i in l:
for j in i:
print(j)
②.访问特定下标的元素
例：for i in l:
print(i[下标])
8.列表的运算
1）列表的拼接用‘+’
2）列表的重复 ‘*’
3）列表的比较
先比较第一个元素的大小，如果第一个元素大小相同，那么继续比较后面的元素，相同类型的数据可以比较
4）成员关系
in 、not in
例：l[1,2,3]
2 in l
十二、元组tuple
1.元组的创建
1）.创建方式
①.可以用(元素,元素)的形式来创建
可以存放各种数据类型的数据
②.实际上“,”才是元组的创建要素
例：a=1, (1,) a=(1) 1
2.元组--被禁锢的列表 （元组不能添加，也不能删除）
1）元组创建好以后，不能添加元素，不能删除元素，不能修改元素
注意：在特殊情况下，元组的元素也是可以进行修改的。
例： >>> a=([1,2,3],[4,5,6],[7,8,9])
>>> a
([1, 2, 3], [4, 5, 6], [7, 8, 9])
>>> type(a)
<class 'tuple'>
>>> del a[0][1]
>>> a
([1, 3], [4, 5, 6], [7, 8, 9])
3.元组的访问
1）.下标访问
2）.for循环遍历
4.元组的运算符
1）.元组的拼接用“+”
注意：当一个元组只有一个元素的时候，进行拼接时，括号和逗号都不能省
例：>>> a+(1,)
(1, 2, 3, 1)
2）.元组的重复用“*”
3）.元组的比较
先比较第一个元素的大小，第一个大的，该元组比较大。如果第一个元素大小相同，那么继续比较后面的元素，相同类型的数据可以比较
4）.元组的逻辑运算
not and or 与列表相似
5）.成员运算符
in 、not in
5.元组常用的方法
1）.count(元素)
元素在元组中出现的次数
十三、字符串
1.创建形式
单引号，双引号，三引号
2.字符串的增删改
字符串不支持增加，删除，修改
列表中可以用下标的方式来修改元素
例：
l=[1,2,3]
l[0]=666
print(i)
l=[666,2,3]
3.字符串的访问
1.用下标访问
例：In [3]: a
Out[3]: 'asdasdas'
In [4]: a[2]
Out[4]: 'd'
2.循环遍历
n = input("请输入一个整数：")
s=0
for i in n:
s+=int(i)
print(s)
3.字符串的方法
1）.capitalize()
返回一段首字母为大写的字符串
2）.caseflod()
返回全小写的字符串
3）.center()
返回居中的字符串，整体长度可以在参数中设定
例：a.center(30)
4）.count()
查询字符串中，字符的数量，可以在指定位置查询：如果没有查到，返回0不会报错
例： In [14]: a
Out[14]: 'hello world'
In [15]: a.count("l",0,3)
Out[15]: 1
In [16]: a.count("l",0,4)
Out[16]: 2
5）.endswith()
判断该字符串...结尾，结果返回一个布尔值
6）.startwith()
判断该字符串...开头，结果返回一个布尔值
7）.find()
返回查找某字符串在该字符串内的下标，如果能找到，则返回它的下标，如果找不到返回-1不会报错
例： In [17]: a.find("d")
Out[17]: 10
In [18]: a.find("d",0,10)
Out[18]: -1
In [19]: a.find("d",0,11)
Out[19]: 10
8）.index()
返回元素下标，若没有改元素，报错
9）.isalnum()
判断字符串中是否都由数字和字母组成的，返回一个布尔值
10）.isalpha()
判断字符串中是否都由字母组成，返回一个布尔值
11）.isdecimal()
判断字符串中是否都是10进制
12）.isdigit()
判断字符串中是否都是数字
13）.isnumeric()
判断字符串中是否都是数字字符，可以识别汉字
14）.islower()
判断字符串中字母是否都是小写，返回布尔值
15）.isspace()
判断字符串中，是否都是空格，返回布尔值
16）.istitle()
判断字符串中，开头是否是大写字母，返回布尔值
17）.isupper()
判断字符串中字母是否都是大写，返回布尔值
18）.join()
将原有字符串插入到可迭代对象中，可迭代对象，元素要是字符串类型
19）.ljust()
将原有字符串左对齐，根据给定的字符串总数，其余字符用空格填充
20）.rjust()
将原有字符串右对齐，根据给定的字符串总数，其余字符用空格填充
21）.lstrip()
将左侧空格清空
22）.rstrip()
将右侧空格清空
23）.replace(旧的，新的，替换几个)
可以将原来的旧字符串替换成新的字符串
例： In [35]: a="hello world"
In [36]: a.replace("h","H")
Out[36]: 'Hello world'
In [37]: a.replace("l","L",2)
Out[37]: 'heLLo world'
4.格式化输出
1）.format()
形式1：位置参数
例：In [42]: "{0}{1}".format("hello","world")
Out[42]: 'helloworld'
形式2：关键字参数
例："{a}{b}".format(a="hello",b="world")
Out[43]: 'helloworld'
形式3：位置参数，关键字参数混用
例："{0}{a}{1}".format("my","hello",a="world")
Out[46]: 'myworldhello'
注意,位置参数要在关键字参数之前（指的是format中的位置参数与关键字参数）
{}’可以被‘{}’转义，如果想打{helo},那么
例： "{{{0}}}".format("hello")
Out[50]: '{hello}'
5.格式化输出2
%c 格式化字符编码
%d 格式化数字
%f 格式化定点数
%e e计法,科学记数法
%g 按实际情况转化成定点数或者e计法（%e,%f）
%o 转换成八进制
%x 转换成十六进制
%s 转换成字符串
十四、序列
1.列表、元组、字符串
1）.他们都是可以通过下标来获取某一个元素
2）.他们的起始下标都是0开始并且支持负数索引
3）.他们都支持分片操作
4）.他们都支持相同的操作符
a.拼接操作符“+”
b.重复操作符“*”
c.成员关系操作符in、not in
d.比较运算符 <、>、<=、>=、!=
e.逻辑运算符‘not、and、or’
凡是有以上特性的，我们统称为序列
2.序列的方法
list()
将可迭代对象转换为列表
tuple()
将可迭代对象转换为元组
str()
将可迭代对象转换为字符串
len()
返回序列的长度
sum()
返回数字类型的和
max()
只能比较相同类型的数据，返回序列中的最大值
min()
只能比较相同类型的数据，返回序列中的最小值
十五、基本概念
1. 变量：是一个系统的元素，拥有指向对象的连接空间
2. 对象：被分配一块内存空间，存储其代表的值
3. 引用：是自动形成的从变量到对象的指针
4. 类型：Python中无类型的，对象的类型
5. 不可变对象：一旦创建就不可修改的对象（str，元组，数字）
6. 可变对象：可以修改的对象（列表）
7.深00：
不可变对象，没有深浅拷贝一说
可变对象，才能谈上深浅拷贝
8.浅拷贝的方式
1）.浅拷贝的方式
import copy
a=[1,2,3,4]
b=a
c=a[:]
d=copy.copy(a)
2）.深拷贝的方式
import copy
a=[[1,2,3],2,3]
b=copy.deepcopy(a)
3）.深浅拷贝的意义
浅拷贝，节省内存空间
深拷贝，数据的清洗，修改，入库，对原数据进行复制，防止数据修改之后，找不到源数据（深拷贝）
9.小结
1）. 深浅拷贝是对原对象的复制，占用的内存空间不一样
2）. 不可变类型的对象，对于深浅拷贝无影响，最终的地址和值都不会改变
3）. 可变类型：
=：拷贝地址---浅拷贝
copy：浅拷贝---地址不等，元素的地址相等
deepcopy：深拷贝--地址不等，元素的地址不相等
十六、函数
1.函数的定义
1.关键字 def
2.空格
3.函数名
4.括号
5.冒号
def 函数名(参数，参数):
代码
参数，参数列表，形式参数
2.函数的调用
函数名()的形式
3.结构化编程
非结构化编程：一组逻辑写在同一段代码中
结构化编程：一组逻辑写在不同的代码中，通过相互调用，配合完成
4.函数的运行机制
当函数调用的时候，系统会自动找到函数名，进入函数内部，逐步执行函数，当函数执行完毕
会返回到函数的调用处
5.函数的特点
1.避免代码冗余
2.函数具有可重用性
3.函数具有可维护性
4.函数的灵活性
6.函数的定义
1.函数也可以定义在另一个函数的内部
2.函数和变量一样，在使用之前要先定义
3.定义要使用关键字def
4.函数名符合标识符命名规则
7.函数的参数
1.函数的参数又叫参数列表，或者叫形参列表
参数可以有多个，中间用逗号隔开
形式参数与实际参数：
形式参数：在函数定义的时候，函数名后括号内的参数，我们叫它形式参数
实际参数：在函数调用的时候，函数名后括号内的参数，我们叫它实际参数
2.位置参数
我们实际的参数会按照形式参数的位置，依次传递参数
3.关键字参数
我们实际的参数会按照指定的关键字参数，依次传递参数
8.函数的返回值
1.如果不写函数返回值，则默认返回一个None
2.如果有返回值，则在函数末尾添加return语句
3.返回多个数据，return后加上返回参数，用逗号隔开，则系统返回值打包成一个元组
9.变量
全局变量：在函数最外层定义的变量是局部变量（没有缩进）
使用范围：
从变量的定义开始，到包含它的代码块儿结束--整个文件
局部变量：在函数内部的变量
使用范围：
从变量的定义开始，到包含它的代码块儿结束
当全局变量和局部变量发生冲突时，以局部变量为准
10.global
global 可以影响全局变量
用法：global +变量
变量=值
例：
a=100
b=200
def add():
global b #利用global关键字声明 全局变量
b=100
a=50
c=a+b
return a,b,c
print(a,b)
print(add())
print(a,b)
利用global关键字，创建的局部变量进行修改，原全局变量也被修改
11.nonlocal
nonlocal影响的范围是其上一层函数变量
用法： nonlocal+变量
变量=值
例：
a=100
def add2():
a=200
def add1():
#nonlocal a
a=50
b=a+50
return b
print(add1())
print(a)
add2()
print(a)
12.lambda函数
匿名函数
1.创建形式：lambda关键字 变量，变量：函数的实现
如果有多个变量，用逗号隔开。
例：
a=lambda x:x+3
print(a(3))
2.lambda函数的好处：
1.如果有些功能只是使用一次，临时的功能，使用lambda表达式更合适，更简洁，不用创建一个完整的函数，也不用起名字
2.使代码更精简，提高代码的可读性。
13.递归
1.自己调用自己
2.注意避免无穷递归，递归层数是有限的
2.求N的阶乘问题
例：
#n!=n*(n-1)!
#(n-1)!=(n-1)*(n-2)!
#(n-2)!=(n-2)*(n-3)!
#(n-3)!=(n-3)*(n-4)!
#(n-4)!=(n-4)*(n-5)!
#(n-5)!=(n-5)*(n-6)!
def jieCheng(n):
if n==1:
return 1
return n*jieCheng(n-1)
print(jieCheng(6)
什么时候用递归：
1.解决一个大问题，大问题可以拆分成小问题 #求n！，（n-1）！ ，（n-2）！...
2.小问题的解决方法和大问题相同 # n*（n-1）！
3.我们能解决一个小问题 # 1!=1
14.内嵌函数
在一个函数内定义另一个函数
1只能在包含其代码块的内部调用.
2内嵌函数的整个作用域，都在外部函数之内
2注意：
def outer():
a=10
def inner():
a=a+5 #报错
return a
return inner()
print(outer())
15.函数的嵌套调用
函数的嵌套调用：在一个函数内调用另一个函数
def delta（）：
def jieFangCheng（）：
delta（）
这种形式就称之为函数的嵌套调用
例：
def shiFouYouJie(a,b,c):
#处理是否有解
result=b**2-4*a*c
if result>=0:
return True
else:
return False
def jieFangCheng(a,b,c):
#判断是否有解
if shiFouYouJie(a,b,c):
#如果有解进一步求解
delta=b**2-4*a*c
x1=(-b-delta**0.5)/(2*a)
x2=(-b+delta**0.5)/(2*a)
return x1,x2
#如果没有解，输出无解
else:
return '无解'
print(jieFangCheng(1,1,-1))
16.闭包
Python：如果在一个函数内部对外部的作用域的变量进行引用（内嵌函数），外部函数以内部函数名进行调用，这个内部函数就是一个闭包
例：
def outer():
a=10
def inner():
b=a+5
return b
return inner
print(outer()())
十七、文件IO
1.文件的读取
open(文件名（全名），模式.....)
文件名：路径，文件名，扩展名
打开模式：
1）r read 只读
2）w write 覆写 如果文件之前有内容，会被覆盖掉。如果没有这个文件，则会创建一个文件，并写入
3）a 追加写入，在文件末尾追加写入
4）b 二进制，可以和r,w,a配合使用
5）x 创建文件，写入文件
6）+ 可读写
2.文件读写的方法
1.read() 读取
2.close() 关闭
3.write() 写入
4.readline() 读取一行
5.tell() 告诉你指针在哪
6.seek(偏移量，位置) 偏移指针，位置有三个可以用的参数，第一个0，文件的起始位置；第二个1，指针的当前位置，第三个2，文件的末尾。（只适用于二进制文件，非二进制文件，可以使用0这个起始位置）
注意：所有指针相关，支持负数。
3.pockle
1.pickle只支持二进制
2.使用pickle需要导模块 import pockle
3.pickle的两个方法
pickle.dump(内容，文件)
将内容倾到进文件中，dump倾倒的意思
pickle.load(文件)
将文件加载
例：
#文件保存
imoprt pickle
l=[1,2,3,4]
f=open('222.txt','wb')
pickle.dump(l,f)
f.close()
# 文件读取
import pickle
f=open('222.txt','rb')
l=pickle.load(f)
f.close()
十八、字典
key:键 （目录中的单词）
value:值 （单词的含义）
key-value：键值对（项）
字典是Python中唯一的映射类型，指两个元素集之间的一一对应关系
字典不是序列，字典是映射类型
字典的键必须是可哈希类型--不可变对象，值没有限制。
字典的创建和访问
字典的创建： dict
1. 直接创建：
字典名字={键1:值1，键:值2...}
2. 空字典：{}
3. 利用工厂函数创建字典
dict(mapping)
值接收一个参数，把多个映射关系打包成一个参数
d=dict(one=1,two=2,three=3)
# {'one': 1, 'three': 3, 'two': 2}
字典的访问
1. 直接访问：名称[键名]
2. 修改键对应的值
d['one']=99
{'one': 99, 'three': 3, 'two': 2}
3. 字典添加一个键值对
通过：名称[键名]=值 的形式直接添加
4. 直接访问字典中不存在的键值对，会报错
字典的方法
1. fromkeys(可迭代对象,值=None):
创建一个新字典，可迭代对象的每一个元素，作为字典的键，值是共享的，默认为None
2. keys():
返回字典的键
3. values():
返回字典的值
4. items（）：
返回字典的键值对
5. get(key):
通过键获得字典中的值
6. in/not in：
查看键是够存在于字典中
7. clear()
清空字典
8. copy（）：
拷贝（浅拷贝）
a={'one':[1,2,3]}
b=a.copy()
#b={'one':[1,2,3]}
9. pop():
弹栈：
pop要有参数，字典没有顺序
删除指定键值对，同事返回对应的值
10. update():
利用字典的映射关系，更新字典
b={'four':99}
d.update(b)
十九、集合
集合的创建
1. 直接创建：
变量名={元素1，元素2...}
2. set():
set(元组，列表，字符串，集合)
1.访问
用for循环遍历
2.新增一个元素
S.add(元素)
3.新增多个元素
.update(可迭代对象)
4.删除一个元素
.remove(元素)
5.集合支持“-”操作符
a={1,2,3}
b={1,3}
a-b={2}
去掉相同元素
6.支持成员关系操作
in、not in
7.运算比较符
支持
例：a>b
实际上是a包含b的意思
例 {3,4,5}>={3,4,5}
>> True
8.不可变集合
关键字：frozenset
定义：
变量名=frozenset（可迭代对象）
frozenset也可进行减法操作，结果一定是frozenset，
同时返回一个新的frozenset，以前的不可变集合不变
扫一扫
1030
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
