python电子版笔记（基础）

注意：python变量的定义相当于指针,a=1相当于生成一个a的指针变量，指向数值为1的地址，若a为列表，则相当于a变量存储的是指向列表的地址，列表的地址存储的是一系列指向a[0]等地址的指针数据。id(对象)相当于查找对象指向的地址。b=a相当于变量b指向的地址和a相同,即a,b为同一个对象,但a的重新定义不等于b的重新定义。如果a,b是可修改对象，修改a相当于修改b。
可变对象可修改，可重新定义，不可变对象只能重新定义。
当变量重新定义时，如果变量指向的地址没有其他变量指向，这个地址会被回收。
#a = 100
#b = 100
#a is b True
#a=300
#b=300
#a is b False

因为在python当中存在内存池，范围[-5,256]

范围内内存地址一致，范围外内存地址不一致

01基本概念和基本数据类型
变量是编程语言中最基本的概念，和字面意思一样，指的就是他们的值可变，和我们以前学习的方程类似，变量可以代入任何值。
2数字类型：
整数：int
浮点数：float
布尔型：bool:(True,False)
数值类型计算
/ 除法
// 整除
% #取余
** #幂运算
在Python中bool型的True和False分别等同于 1 和 0， 也可以直接进行运算
3.字符串
isinstance()判断类型 #s=1 isinstance(s,str)返回False或True
字符串也可以进行加法和乘法的运算，但是都是进行字符串的拼接
字符串的拼接
1.’+’
2.join方法 ‘ ’.join([a,b,c,d,e,f])
3.‘%s%s%s’%(a,b,c) %s占位符
4.format方法 ‘{0}{1}{2}’.format(s,t,r)
5.format方法简写 f’{s}{t}{r}’
字符串格式化：
1.‘%6d’%123 #%d格式化整数，6表示字符串长度
输出’ 123’
2.‘%09.2f’%357.268 #%f格式化浮点数，0表示用0填充；2表示只保留2位小数，9表示输出字符串的长度
‘000357.27’
3.‘%c’ % 97 #格式化成ASCII码
‘a’
4.’%o’ % 8 #八进制输出
‘10’
5.’%x’ % 16 #十六进制输出
‘10’
6.’%e’%10000 #%e格式化输出科学计数法
‘1.000000e+04’
7.’%r’%’123’ # %r 对象原样输出
简写 r’123’

字符串的format方法
format同样也是字符串格式化输出方法，并且功能更加强大实用，推荐使用,并且在3.5之后的版本增加了f-string的用法，基本用法和format类似

‘{a:bcdefg}’.format(a=**),a变量，:引导符，b填充字符，c{对齐方式<>^左右中对齐}，d宽度
e{ , 数字的千位分隔符,适用于整数和浮点数},f{ . 浮点数小数部分的精度或字符串的最大输出长度},g{类型 整数类型b,c,d,o,x,X浮点数类型e,E,f,%}

整数：
b: 输出整数的二进制方式
C: 输出整数对应的unicode字符
d: 输出整数的十进制方式
o: 输出整数的八进制方式
x: 输出整数的十六进制方式
X: 输出整数的大写十六进制方式
浮点数：
e: 输出浮点数对应的小写字母e的指数形式
E：输出浮点数对应的大写字母E的指数形式
f :输出浮点数的标准浮点型形式
% :输出浮点数的百分比形式
字符串处理函数len(x)返回字符串x的长度或者是其他组合类型的元素个数
str(x)把任意类型转换为字符串形式
chr(x)返回Unicode编码对应的单字符
ord(x)返回单个字符对应的Unicode编码
hex(x)返回整数x对应的十六进制的小写形式
oct(x)返回整数x对应的八进制的小写形式
字符串处理方法
方法 描述
a=str.lower() 以小写的方式全部返回str的副本
A=str.upper() 以大写的方式全部返回str的副本
a=str.split(sep=None) 返回一个列表，以sep作为分隔点，sep默认为空格
a=str.count(sub) 返回sub子串出现的次数
a=str.replace(old,new) 返回字符串str的副本，所有old子串被替换为new
str.center(width,fillchar) 字符串居中函数，fillchar参数可选
str.strip(chars) 从字符串str中去掉在其左侧和右侧chars中列出的字符
str.join(iter) 将iter变量的每一个元素后面增加一个str字符串
转义字符
转义字符 描述含义
\b 退格，把光标移到前一列的位置
\f 换页符
\n 换行符
\r 回车
\t 水平制表符
\v 垂直制表符
类型转换函数
int(x)：将x转换为整数
float(x)：将x转换为浮点数
str(x)：将x转换为字符串
4.常见数值模块
浮点数高精度计算
可以使用 decimal 模块来做浮点数的精确计算,使用时注意传入的是一个字符串
Import decimal
Decimal.Decimal(‘str’)
math模块
Math模块有常见的数学函数，有需要的可以在这个模块里面找找
Math.pi=3.1415926535
math.ceil(i)向上取整
Math.floor(i)向下取整
Math.fabs(i)取绝对值
Math.sqrt(i)开平方
Math.pow(x,y) x的y次方
重要：dir(math)查询math模块里的属性和方法
dir(对象)查询对象的属性和方法
Help(函数或方法)查询函数方法功能
02条件语句和while循环
if语句：
!= 不等于
== 等于
三目运算
True if a>5 else False
后面这种同样也是判断，但是要简洁很相当多，这样可以节省很多的代码，让代码看起来更加简洁,注意：只有简单if判断可以使用，过于复杂判断就不要使用了，那样会影响代码的可读性
逻辑运算
常见判断符

   <	       >=	       <=	     ==	      !=

大于 小于 大于等于 小于等于 等于 不等于
与逻辑
当需要同时判断多个内容的时候，可以使用 与、或、非 等逻辑来同时判断多个条件
and
表示“并且”或者“和” 的意思，只有当 and 两边都是为真的时候，才会返回 真， 在其他语言中常用 & 来表示 and

或逻辑
or
表示“或者”的意思，只要两边存在真，就会返回真，都会假才会返回假， 在其他语言中常用 | 来表示 or

非逻辑
not
表示“取反”的意思，也就是真的会变成假的，假的会变成真的，在其他语言中常用 ！ 来表示 not

逻辑短路(代码执行顺序从上到下，从左到右，and,or有逻辑短路，not没有逻辑短路
)
逻辑运算过程中，如果已经能够得到最后的值，则不会再进行后面的判断，这个称为逻辑短路

三者之间的优先级：not>and>or
Python底层会把连续判断转化成and 连接的形式
如：1>2>3 ------>1>2 and 2>3

注释快捷键：选中，Alt+3,
取消注释快捷键：选中，Alt+4

while循环
break提前终止程序，跳出当前循环,不执行else
continue跳出本次循环，开始下次循环,执行else语句
while 循环后面也可以接上else循环，当循环正常结束时，就会执行else 内的代码
while 后面也可以直接跟上True，但是内部就必须要使用break来终止循环
使用break终止的循环，是不会执行else的内容
While a<5:
Continue
Else:
Pass
快捷键ctrl+]统一向右缩进，ctrl+[统一向左缩进
print(a,end=’ ’)print 里面的 end 可以设置每个值打印之后输出的字符串，默认是换行

03循环语句和列表元组
for循环，循环的次数由可迭代对象的长度决定，可迭代对象（字符串，列表）
查看是否是可迭代对象的方法 dir(对象)，有’iter’就是可迭代对象
for循环可以把字符串里面的每个元素都依次取出来，自动赋值给变量 i， 然后再执行循环体内的代码块
range 函数可以取到一个范围内的整数，相比 while 要方便很多
for i in range(10):
for 循环又称为计数循环，是因为 for 循环次数由可迭代对象来决定，我们学过的字符串就是可迭代对象，以及我们后面要学的列表、元组、字典、集合等都属于可迭代对象。 现在大家可以用for循环来判断对象是否是可迭代的。
for i in range(1,10,2)
for循环 和 while循环中都可以使用break 和 continue
同时后面也可以接上else，当循环被break终止时，else不会执行
列表推导表达式
Li=[] 定义空列表
Li.append(i)追加元素
列表推导表达式可以快速生成一个列表，并能筛选列表的值
[i for i in range(101) if i%2 == 0 ]#列表推导表达式
#列表推导式和三目运算混合使用
#li=[i100 if i%2==0 else i10 for i in range(10)]
range(开始值,结束值,步长)#左闭右开，默认从0开始
列表
列表就如同一个菜篮子，可以放菜，也可以放钱
因此列表里面既可以放字符串，也可以放数值类型数据
除此之外，列表里面可以几乎放python的任何对象
len()#查看长度
列表的索引（index）取值
列表中每个元素在列表中的位置称为索引(index)，可以通过索引值来取对应位置上的值

注意：

1. 索引值是从0开始
2. 负索引就是从列表尾部往前数
3. 索引取值超过长度就会报错
   切片 * 左闭右开*
   #li[索引开始值:索引结束值:步长]#从左往右切，步长为正数，从右往左切，步长为负，切片超出范围，就取到最后一个值，切片左右都不写范围的时候，从头切到尾
   列表的增删改查
   查找：可以根据元素，找到元素的索引值 list.index(a)
   #增：li.append(),追加，加到列表最后面
   #li.insert(索引号，数据) 在第几个索引值添加数据
   #li.extend(列表或字符串) 批量添加，加在列表的后面，如果实参为字符串，则一个字符为一个li[n]
   #删除
   #li.pop()默认删除最后一个元素
   #li.pop(下标值)根据下标删除元素
   #li.remove(元素名称)根据元素名称删除元素,如果有多个，删除最前面的一个
   #del li[1:3]批量删除元素
   #li.clear()清空列表

#改 赋值语句
a[n]= **
li[0:3]=’abc’可迭代对象会自动遍历
#li[0:3]=[‘aa’,’xx’,’cc’]可迭代对象会自动遍历，替换数量不需要相同

#列表的其他方法
#a=copy() 复制列表
#a=id()查看id指向，能够通过id指向判断是否为同一个对象，，返回变量的地址
#li.sort()列表排序，会改变原列表 同类型才能排序，否则会出错
#li.sort(reverse=True) 反向排序

#a=li.count(i)统计元素出现的次数
#a=sorted(li)临时排序，不改变原列表
#a=sorted(li,reverse=True)临时反向排序

#元组 tuple 元组不能修改
#元组可以索引取值
#元组也能切片
#元组不能替换元素
#index()根据元素查找对应元素索引
#tu=(1,)元组只有一个元素，也要加上逗号

#元组拆包,(字符串，列表也可以，字典为键值)
#tu=(1,2,3,4,56,8,79,8,7)
#a,b,c=tu按顺序接收元组的元素值,c为列表
#多余的给带号的变量接收，并放在列表里面，带号的是不定长参数
#*号只能给一个变量，也就是只能存在一个不定长参数
04字符串和散列类型

字符串 字符串本身不能够修改

##str1 = ‘hello world’
#字符串方法

str1.replace(‘h’,‘a’) 替换，将h替换成a,原字符串不做更改

str1.replace(‘l’,‘c’,1) 默认符合条件会全部替换，第三个参数表示替换几个

str1.upper() 大写

str2.lower() 小写

str1.capitalize() 首字母大写

str1.title() 标题形式,所有单词首字母大写

##s = ’ hello world ’

s.strip() 去掉两边空格

s.lstrip() 去掉左边空格

s.rstrip() 去掉右边空格

str2 = ‘hello world this is python’

str2.split() 字符串切割，默认以空格作为切割符，切完之后的数据放在列表里面

str2.split(‘o’) 指定以o当做切割符

str2.split(‘o’,2) 也可以限定切割次数

‘he’.join(str2.split(‘this’)) join拼接，返回字符串

str2.index(‘h’) 查找，根据元素名称查找对应元素位置，查找一个

str2.index(‘o’,5) 第二个参数表示从下标5的位置开始查找元素

index()如果没有找到元素，则报错

str2.find(‘o’,5) 如果元素没找到，则返回-1

判断全是中文或者字母组成

‘hello world’.isalpha() False 空格是字符，但空格不是字母

判断全是数字*

‘1234a’.isdigit() False

判断全是大写

‘ABCD’.isupper()

判断全是小写

‘Abcd’.islower()

字符串转义 在print()函数里面起作用

\n:换行*

print(‘hello\nworld’)

\t:水平制表符*，表示八个字符八个字符实现对齐

##print(‘hello\tworld’)

\b:相当于退格键，也就是往前退一格，在cmd命令中才能实现

print(‘hello\bworld’) -> hellworld

\a 系统提示音，在cmd命令中才能实现

\0 产生一个空格

##print(‘hello\0world’)

:取消字符串的转义

##print(‘hello\nworld’)

r:统一取消转义*,表示路径时非常方便

##print(r’\nab\acd\0e\t’)

字符串的编码 以什么形式编码，就要以什么形式解码

encode() 编码 默认以utf-8形式编码

decode() 解码 默认以utf-8形式解码

##str1 = ‘安言’
##str2 = str1.encode(encoding=‘utf-8’)
##str2 = str1.encode(‘utf-8’)
##str2 = str1.encode() # b’\xe5\xae\x89\xe8\xa8\x80’

##str3 = str2.decode # ‘安言’

列表，元组，字符串 序列类型，有顺序

#数字是一个整体，不属于序列类型和散列类型

字典 dict 散列类型 没有顺序可言

##li1 = [‘name’,‘age’,‘city’]
##li2 = [‘安言’,18,‘changsha’]
##print(‘安言今年’,li2[li1.index(‘age’)])

定义一个字典 {}

键和值之间用’:连接，不同的数据之间用’，'隔开

##dic = {‘name’:‘安言’,‘age’:18 ,‘city’:‘changsha’}

dic[key] 通过键取值，注意:字典的键可以为变量，但不能为列表

字典的定义

##dic1 = {} # 1.空字典,a={}是定义空字典不是空集合
##dic2 = {‘a’:1,‘b’:2} # 2.常规定义
##dic3 = dict(a=1,b=2,c=3) # 3.使用dict函数定义字典

字典的增删改查，字典方法

dic = {‘name’:‘安言’,‘age’:18 ,‘city’:‘changsha’}

增

dic.setdefault(key,value) 添加一个键值对 无则增，有则查

查

dic[key] 根据键取值，但是如果是不存在的键，会报错

dic.get(key) 根据键取值，如果不存在，则返回空（None）

改

dic[key] = value 无则增，有则改

dic.update({key:value, key:value}) 无则增，有则改

删

dic.pop(key) 删除对应键的键值对数据

dic.popitem() 根据添加进去的顺序删除数据，后添加先删除

dic.clear() 清空字典里面所有数据

其他方法

dic.keys() 获取字典里面所有的键名

dic.values() 获取字典里面所有的值

dic.items() 获取字典里面所有的键值对，键值对放在元组当中

集合 会自动去重,里面的值具有唯一性 {} set set(a)其他类型数据转为集合

##set1 = {1,2,3,4,1,2,3,4}

集合是无序的 散列类型

##set1 = {1,‘a’,‘b’,2,3}

集合的运算

##set1 = {1,2,3,4,5,7}
##set2 = {1,3,5,7}
##set3 = {‘a’,‘b’}

交集&：两个集合中相同的元素

##print(set1 & set2)

并集|：两个集合的元素合并在一起

##print(set1 | set3)

差集- ：前面的集合减去后面的集合

##print(set1 - set2)

##set1 = {1,3,5,7}

增

set1.add(‘a’) 往集合当中增加一个数据

set1.update({11,22,33}) 批量增加

删

set1.pop() 随机删除

set1.remove(22) 根据元素名称删除对应元素

集合是不能进行修改操作的，因为集合是无序的

##set1 = {1,2,3,4,5,6}
##set2 = {4,5,6}
##set3 = {3,4,5}

set1.isdisjoint(set2) True 判断两个集合之间是否没有交集

set2.issubset(set1) True 判断前面的集合是否被包含在后面的集合里面

set1.issuperset(set3) True 判断前面的集合是否包含后面的集合

运算符总结

身份运算符 is is not

a == b True

#a = 100
#b = 100
#a is b True
#a=300
#b=300
#a is b False

因为在python当中存在内存池，范围[-5,256]

范围内内存地址一致，范围外内存地址不一致

a is b False 判断两者是否是同一个对象

is not 取反

成员运算符 in判断元素是否属于对象里面的内容(即和对象里的内容相等) not in 取反

不管是序列类型还是散列类型都能使用成员运算符，数值类型不行

##li = [1,2,3,4] # 1 in li # 6 not in li

内存地址

如果修改过后内存地址不变，就是可变对象

可变对象：list、dict、set

不可变对象： 数值、str、元组

#深浅复制，只在嵌套列表当中存在
#li.copy()浅复制
##li = [1,2,3,[4,5,6]]

#深复制
#import copy
#li = [1,2,3,[4,5,6]]
#li1 = copy.deepcopy(li)
第五节课–函数
函数的定义和调用
自定义函数
def是定义函数的关键词
函数调用：函数名（自定义）
返回值 return
当不存在返回值时，默认返回None
当存在返回值时，返回具体的数据
返回值之后的代码不会执行
Example:return x,y,z
func函数名，代表函数体，也就是函数本身
func(1,2),代表函数调用，也就是函数执行之后的结果
##函数的参数，参数没有数据类型的限制
#顺序：先必备，再默认，最后不定长参数（定义函数时），
#在输入实参调用函数时，可以按顺序执行，当没有或不输入不定长参数1时，可以用x=1的形式，这时可以不考虑顺序
#1.必备参数（x），定义了几个必备参数，函数调用就需要传几个参数值，一个也不能多，一个也不能少
#2.默认参数（y）,y=值，当不给默认值的时候，会把默认值给默认参数接收，当传值，就是我们传进去的值
#3.不定长参数（*args,**kwargs）
#args是不定长参数，数据放在元组里
#kwargs是不定长参数，数据放在字典里面，键只能是字符串类型
#args和kwargs都不是规定写法，但是这是规范写法

-> str这种语法指明这个函数的返回值是什么数据类型，主要用于团队协作

例子：def func(x,y=2,*args,**kwargs) -> str:
#help(func) 可以返回函数或方法简介

#拆包
return 1,2,3
对于函数来说，当返回多个数据时，是以元祖的形式返回的，可以拆包

#函数的作用域
在函数里定义的变量为局部变量，函数内不能直接使用函数外变量，函数外不能直接使用函数内变量
global x #声明全局变量
nonlocal x #声明局部变量，即声明当前函数外的变量

#闭包（外层函数返回内层函数的函数体，这就是闭包）
如：
def func():
lv = 5
#增加血量
def func1():
nonlocal lv
lv+= 1
print(lv)
def func2():
nonlocal lv
lv -= 1
print(lv)
return func1,func2
#递归函数：自身调用自身
##def func(n):

if n==1:

return 1

else:

return func(n-1)*n

匿名函数

通过lambda关键字定义

匿名函数会自动返回，x是参数

##a = lambda x:x+1

上面的匿名函数相当于下面的有名函数

##def a(x):

return x+1

##li = [2,4,6,8,10]
##def func(x):

if x>5:

return x

filter()：过滤器

第一个参数是函数体，第二个参数是可迭代对象

##print(list(filter(func,li)))

##print(list(filter(lambda x:x>5,li)))

map()：对于元素进行统一操作

第一个参数是函数体，后面可以是一个或者多个可迭代对象

##li = [2,4,6,8,10]
##print(list(map(lambda x:x-1,li)))

zip():把两个可迭代对象合成一个字典，实现数据配对

##tu = (‘a’,‘b’,‘c’)
##li = [2,4,6]
####print(dict(zip(tu,li)))
##print(list(zip(tu,li)))

回调函数:把一个函数的函数体当做参数传递给另外的一个函数去使用

##def func1(f):

f()

print(111)

##def func2():

print(222)

##func1(func2)在这里插入代码片