（新手向，有错误欢迎指出 ）
一.基本字符
1.写注释用#
2.多行注释：”””(三引号)
内容
内容（可换行）
“””
3.换行符：\n
4.“123””123”=”123123”
5.若要分行:print(“hello,I’am Tom\nJim”)
6.a=[1,2,3,] 方括号是列表
7.方括号，圆括号，花括号可以直接换行
8.多行成一行写(加分号)：a=1;b=2;c=3
二.基本查询
1.id 查地址
2.type 查字符类型
3.import keyword
print(keyword.kwlist)查关键字
4.print(dir(__builtins__))查内置函数
5.help打开函数文档
三.关键字，函数名
1.关键字False, None, True, and, as, assert, async, await,
break, class, continue, def, del, elif, else, except, finally, for,
from, global, if, import, in, is, lambda, nonlocal, not, or, pass,
raise,return, try, while, with, yield
2.内置函数abs, all, any, ascii, bin, bool, breakpoint, bytearray,
bytes, callable, chr, classmethod, compile, complex, copyright,
credits, delattr, dict, dir(列模块内的函数), divmod, enumerate,
eval, exec, exit, filter, float, format, frozenset, getattr, globals,
hasattr, hash, help(详细查询), hex, id, input, int, isinstance,
issubclass, iter, len, license, list, locals, map, max, memoryview,
min, next, object, oct, open, ord, pow, print, property, quit,
range, repr, reversed, round, set, setattr, slice, sorted, staticmethod,
str, sum, super, tuple, type, vars, zip
3.部分详解
(1)print:[1]改变间隔用 sep=’ ’(多个内容中部默认是一个空格，可以改变) eg.print(‘hello’,sep=’%’)
[2]改变结尾用 end=’ ’(多个内容中部修改) eg.print(‘hello’,end=’%’)
(2)input:[1]写入东西要用引号
[2]输入的内容都会成为字符串
(3)int:生成一个整数，但是不改变(eg.input中赋的值int后仍为str)
四.变量
1.特点
(1)可以直接声明变量名称
(2)允许多个变量指向同一个值（同一个内存多个名字）
(3)在python中修改变量值的操作不是修改了变量的值而是改变了变量指向的内存地址
2.命名规则
(1)变量名只能由字母，数字，下划线组成（字母，下划线可开头）（不能有空格）
(2)Python3中文可做变量
(3)变量名区分英文大小写
(4)关键字，函数名不能作为关键字 比如Pi（π）
（不允许以数字开头命名变量）
五.导入模块
1.基本格式：[方式一] (1)导入import 模块名
(2)使用函数 模块名.函数
[方式二](1)导入 from 模块名 import 不想加前缀的函数(或者用*,此时可所有内容都不加前缀) 但是加*会占用许多空间
2.给模块名起新名字 import 模块名 as 新名字
给函数起新名字 from 模块名 import 不想加前缀的函数 as 新别名
六.数字(pycharm的某些输出要print,Anaconda Prompt一类不需要print,eg.bin(10))
1.数字类型：int,float,bool,complex生成相印类型的数，而不是改变原来的数
(1)bool:[1]bool(‘’) 注:无空格是false
[2]bool(‘ ’) 注:一个及以上空格是true
2.数字类型特点：不可变
3.(1)数转化为二进制:bin(数),得0b,但是得出的二进制数不可计算，为字符串类型
(2)将数转化为八进制:oct(数),得0o
(3)将数转化为十六进制:hex(数),得0x
4.2e3=2000.0(注:e后为整数，前可为小数，e加一个数是10的几次方)
- 实数和虚数:(1)eg. a=3(默认为浮点数)+2j(j为虚部单位)
(2)查看实部和虚部: a.real(查看a的实部)
a.imag(查看a的虚部)
(3)生成复数:complex(实部,虚部) 只写一个数字则默认:0j
6.算数运算符:+(加) -(减) *(乘) /(除，得结果为浮点数) //(整除) %(求余数) **(求幂)(注:eg.-2**2=-4,(-2)**2=4,因为**优先，所以还要加个括号)divmod()
7.绝对值:abs(数)
得整除和余数:divmod(被除数,除数)
求幂:pow(底数,指数)
- 复合赋值运算符:(1)eg.a=3
a=a+1 (整体可化为a+=1,同理有a-=1,a*=1)
七.字符串
1.字符串本身有单(双)引号则用双(单)引号在外面
2.转义字符(1)加一个\，其后的字符会变得普通
(2)加一个\t,产生4个空格的空白
(3)加一个\\，得\
(4)加一个\n,换行
3.原始字符串:r或者R加在字符串前可以让后面所有字符含义失效
eg.print(r”hello \nworld”)
4.有序的序列:(1)索引(正负索引,正的是从前往后，负的是从后往前):
eg. a=’hello,world’
a[1]
.......................................此处[ ]为索引,其中数字是所求对应序号的字符串的字母
得’e’
(2)该索引不支持字符出修改:a[1]=0,这是错的
5.字符串的拼接:(1)“123””123”=”123123”
(2)a=’hello’ b=’world’ 拼接为 a+b
(拼接用+,+号两边字符串类型相同,生成新字符串) eg.[1,2,3]+[4,5,6]之类的也可
6.分界线:(1)重复:”_”*50 (注:重复50次,其他类型也可如此重复)
八.列表
1.创建:[ ] (注:可以放入任何类型包括列表也可以)
2.函数:list 把其他类型转化为列表 (注:空的可以,数字不行)
eg. b=list(‘hello’)
b
得[‘h’,’e’,’l’,’l’,’o’]
3.列表的删除:del b 注:(1)del加上一个空格，再加上一个列表比如b
(2)del是删除一个对象，其他也一样
4.(1)列表元素的访问:(1)a=[1,2,3]
a[数字]..................................为索引
(2)搜索字符串中某个字母 eg.a=[1,2,3,’hello’,5,6]
a[3][4].......................注:[3]是字符串位置,[4]是字符串中要搜索的字母的位置
(2)列表元素可赋值:eg.a[0]=10
5.向列表添加元素:(1)在列表后插入使用+号(等于生成一个全新的列表)
(2)在列表后插入使用+=号(等于在原列表中添加元素) eg.a+=[3,4]
(3)在列表后插入使用append()
eg. a=[1,2,3,4,5,6]
a.append(1)
(注: . 前为列表,且不可以添加多个参数,若加入字符串,则为整体)
(4)在列表后插入使用extend()
eg. a.extend()..........一个参数
或a.extend([])........此时可以放入多个
(注:也可以加字符串,但是列表中字母会散开)
(5)在列表内部插入使用insert()
eg. a=[1,2,3,4,5]
a.insert(位置,插入的内容)
(注:也只能插入一个元素)
6.从列表中删除元素:(1)使用del eg.del a[1]
(2)使用pop()
eg.(1)a.pop()默认删除最后一个,且有返回词
(2)删除元素,并存在另一个变量eg.b=a.pop(1)
注:此处 (1)为删除的元素
(3)使用remove()
eg.(1)删一个l a=[‘h’,’e’,’l’,’l’]
a.remove(‘l’) 注:删除第一个l
(2)全删完 ‘l’ in a 也可以用 ‘l’ not in a来判断
(注:先检测元素在不在这个列表里,且只能判断一层的,即列表内部的列表内的元素没法查找)
7.列表切片操作: eg.a=[1,2,3,4,5,6,7,8,9]
(1)print(a[0])...................一个元素
(2)a[0:3].................从0到3，但是3号不会出现 注:方向从前到后
(3)若要切最后一个:a[-4:250].......................后界可以无限,但是为了防止后面出错不要用
正确做法：a[-4:].....................最后一个不写
(4)省略掉第一个索引即默认从头开始:a[:-4]
(5)前后都省,即从头到尾,作用:列表的复制:
eg. c=a[:]...............................此时c和a一样,但是id不一样
(6)切片的步长(可正可负,不为零):a[0:4:1]..................步长默认为1
a[-1:-5:-1]................负数步长即从后往前取
(7)只要是序列也可以切片,比如字符串:
eg.c=’hello,world’
c[0:4]
‘hell’
(8)切片赋值:a[1:7]=[]......删除(注:(1)在修改时可以多加几个值,此时多出来的值就直接加入
(2)加入新元素,使用a[x:y]=[元素,元素]是在x处放置)
(9)a.clear():清空列表
(10)浅复制:1.b=a.copy()
2.a=copy.copy(a)........................导入函数copy
3.a=a[:]
深复制:导入copy模块使用a.deepcopy()
(注:区别:浅复制在修改原列表中列表时会改变,深复制不会)
(11)用count()计数 eg: a.count(5)..................数a中有几个5
(12)index():返回某个值在列表中的所在位置,但只能找第一个,但是可以修改起始范围(eg. a.index(7,9,10).......此处9为起始,10是末尾)
eg. a.index()
(13)reverse():反转列表(只能反转列表)且反转a本身,所以不要print(a.reverse()),要找a本身 eg. a.reverse
(14)reversed():反转任何满足函数参数条件的 eg. b=reversed(a) 但是要用列表显示结果
九.for循环
(1)列子:(1)大写
members=['alice','zhangsan','lisi','bob','jo']
a=[]
for i in members:......................i可以替换成其他任何字母
a.append(i.capitalize()).............capitalize是大写首字母
print(a)...................此处print定格则只输出最后的结果,若与a.append()等对齐则每次循环都会输出一次
(2)反转
b='hello'
c=reversed(b)
x=''...................................利于打印结果是字符串
for i in c:
x+=i
print(x)
(2)sort排序:1.默认从小到大
eg.
a=[1,2,3]
a.sort()
print(a)
2.不会返回新的列表,所以打印原列表就好
3.对于字母是根据编码大小来的,ord()可返回字符编码:即可比较字母大小
(①在使用ord()函数时，你需要将要获取Unicode编码的字符作为参数，用单引号或双引号括起来,②记忆ord('A')的返回值是65)
4.可以改变排序:eg.以长度大小来(注:要用 len(‘hello’)函数)
eg.
mebers=[‘lol’,’sjic’,’tom’,’sdau’]
members.sort(key=len).........................key是设置函数规则
print(members)
5.可以反转
eg.
members=[‘lol’,’sjic’,’tom’,’sdau’]
members.sort(key=len,reverse=True)
print(members)
6.只生成列表
十.内置函数
1.eval():计算字符串(即去计算字符串内部的运算),去掉字符串最外层的引号
eg.input中赋的值int后仍为str,此时使用eval,可以让数据回归原来类型
(1)x=input(‘输入一个数’)
a=eval(x)......得x是数,不是字符串
(注:也可x=eval(input(‘输入一个数’)))
(2)a=eval(‘2+5+6’)
print(a)...................直接算出结果
2. exec():执行字符串,运算字符串
eg. exec(‘x=10’)
print(x+100)......................此时x有值,而不是字符串
3.max()与min()
eg. x=[1,2,3,4,5,6] members=[‘Tom’,’Jack’]
print(max(x)) / print(max(1,2,3,4,5,6)) / print(max(members))
4.sum():求和,只能用作数字类型
eg. x=[1,2,3,4,5,6] x=[1,2,3,4,5,6]
print(sum(x)) print(sum(x,100))..........此处100是指为所有和再加上100
5.zip():内部为元组组成
eg. x=[1,2,];members=[‘Tom’,’Jack’]
print(zip(x,members)).......................直接看是看不了的,也可三个元素
a=zip(x,members)
print(list(a))
结果:[(1,’Tom’),(2,’Jack’)]
6.enumerate():枚举
x=[8,7,9]
eg.a=enumerate(x,10)..........此处10为序号,默认是0
print(a)
print(list(a))
结果:[(0,8),(1,7),(2,9)]
7.若要去除6中元组格式:则(1)for i in members:
print(members.index(i),i)
若有相同的序号就会一样,故该方法不是最优,则
(2)for i in [0,1,2,3]
print(i,members.[i])
故引入函数:range()
(3)eg. print(range(5)) / for i in range(1,100,2): .......1是开始,100是结尾,2是步长
结果:range(5) print(i)................结果左闭右开
(4)a=list(range(1,11))
print(a).......................可以转化为列表
(5)for i in range(5):
print(i,members.[i])......................类似7.(2)
不知长度则
for i in range(len(members)):
print(i,members.[i])
(6)for i,j in enumerate(members):
print(i,j).....................类似6如下图,但是没有括号,两个元素来接受就没有括号
(7)序列解包......上述使用的就是序列解包
eg. a,b,c=’hello’
print(a)
print(b)
print(c)
结果:’h’
’e’
’l’
8.元组
(1)b=1,2,3
type(b)...........................此时b自动为元组
但是:
c=(1) / c=1
此时都是整数(哪怕加了括号)而不是元组,若要使其为元组:
c=1, 加个逗号
(2)元组为不可变类型,且不能赋值
(3)元组切片规则和列表一样
(4)元组内部的列表是可变的
eg. c=(1,2,3,[1,2,3])
c[3].append(4)
print(c).........................此时可变
(5)修改元组:将元组转化为列表,再变回来
(6)a,b,c=10,’hello’,[1,2,3,],7,9,0
print(a)
print(b)
print(c)
此时若a,b,c数量不够则a,b,*c=10,’hello’,[1,2,3,],7,9,0
(注:(1)此时加*,a,b后的值都给c,也可以在a,b处加*
(2)若要交换a,c的值即 a,c=c,a)
9.列表推导式(书写列表的简便模式)
(1)写法: 创建一个列表,其中包含前十个整数的平方
eg. a=[1,2,3,4,5,6,7,8,9,10]
b=[i**2 for i in a]
print(b)
(2)写法:只想打印能被3整除的元素的平方
eg. 法一 b=[]
for i in a
if i%3==0:
b.append()
print(b)
eg.法二 b=[i**2 for i in a if i%3=0]
(3)写法:c=[a+b]...............................................a,b均为列表
eg. ① c=[a+b for a in range(5) for b in range(10)]
print(c)
②d=[a+b for a in range(10) for b in range(5)]
print(d)
注:前面和后面顺序不一样结果不一样,另一种结构也是,如下
for a in range(5):..........................此时外层先
for b in range(10):
x.append((a+b))
(4)写出a=[1,1,1,1,1,1,1,1,1,1,1,1......] 100个a
eg.a=[1 for i in range(100)].........................标红部分是控制循环次数
print(a)
十三.循环
1.条件表达式:(1)空语句占位 pass
eg.if : ...........if后如果有数字且不为0解释器会额外输出Ture,若为0则不会输出
pass
print(‘hello’)
(2)if后不能出现赋值语句
(3)is与==
注:①只要值相等,==结果就为True,is判断的是id,所以id不同结果就是False.
②驻留机制:短字符串,小的数字都是相同的id
(4)ord()函数:返回某个字符的编码
eg.ord(‘ ’).......................此处可以为空格或其他
(5)chr()函数:根据编码返回字符
注:①综上字符的大小比较就是编码大小的比较,str和int无法用大小(<,>一类)比较,但是可以使用==(结果都为False),!=(结果都为Ture)
(6)与(and)或(or)非(not):①与的左右两边都是真才为真,或的左右有一个就是真,A真则非A是假
②短路求值:第一个结果是假就输出了,就不会管后面的
③and到假停
eg. 3>5 and print(‘hello’)
False
(7)逻辑运算符:print(3 and 5 and 0 and ‘hello’)...........结果是0,此时遇见假所以打印
print(‘good’ and ‘yes’ and ‘ok’ and ‘100’)............结果是100,都为真所以打印100
print(0 or [] or ‘lisi’ or 2 or ‘ok’)............结果是lisi,只要不是0空就可以
(8)双分支语句:如果条件表达式成立就执行其中的代码,如果不行就执行和其对其的句子,双分支语句if和else不能被隔开,其中内容必须缩进
eg. num=1000
if num >100:
pass
print(‘hello’)
(9)多分支语句:if和else之间用elif,什么都不满足就运行else,也可以不加else
(注:使用match case更方便,python3.10以上才有;whlie和for一般不要混用!)
2.打断循环
(1)break和continue只能在循环内使用
注:break结束整个循环,continue结束当前循环并继续下一次循环
(2)同时处理多个输入值:split()分割字符串
eg.①x=input().split()
a=int(x[0])
b=int(x[1])
if (a-b)%2!=0:
print(a-b)
else:
print(‘不是奇数’)
②’10 7’.split() 空格默认分割
③指定分隔符
‘10,7’.split(‘,’)
(3)map把所有值转化为整型,第一个值必须为一个函数
eg.①
x=input().split()
a,b=map(int,x)
if (a-b)%2!=0:
print(a-b)
else:
print(‘不是奇数’)
②bai,shi,ge=map(int,str(i)) i可以把函数作用到每个序列
if bai**3+shi**3+ge**3==i
print(i)
3.实例
(1)判断一个数的位数
num=int(input('输入一个整数'))
count=0
while True:
count+=1
num//=10
if num==0:
break
print(count)
(2)求10以内素数
法一:
s = []
for i in range(2, 10):
for j in range(2, i):
if i % j == 0:
break
else:
print(i, '这是素数')
s.append(i)
法二:假设成立法
s=[]
for i in range(2,10):else与第二个for对齐,自然结束就执行else
flag=True
for j in range(2,i):
if i%j==0:
flag=False
break
if flag:
print(i,'这是素数')
s.append(i)
法三:计数法
s=[]
for i in range(2,10):
count=0
for j in range(2,i):
if i%j==0:
count+=1
if count==0:
print(i,'这是素数')
s.append(i)
(3)(练习)统计101-200中素数的个数
(4)求斐波那契数
n=int(input())
a1=1
a2=1
if n==1 or n==2:
print(1)
elif n>2:
for i in range(n-2):#无论怎样i会按照规划的取值,所以就算不用i也会循环下去,所以可以当作循环来用
a3=a1+a2
a1=a2
a2=a3#或a1,a2=a2,a3
print(a3)
十四.字典
1.特点:字典是无序的,速度快
2.例子:d={‘tom’:10086,’lily’:10087}
注: :前叫做键,:后叫值,后面有相同的键对应的值会覆盖前面的,键不可重复,且为不可变的数据类型,字典本身是可变数据类型
3.查找eg.print(d[‘tom’])
4.字典可以换行写
eg.person={'name':'zhangsan',
'age':13,
'English':15}
5.字典的函数dict
(1)生成字典
eg.dict(‘hello’)......................错误
dict([‘12’,[3,4],(5,6)])..双值子序列,每个部分的前一个元素变成键,第二个元变成值
或dict(one=1,two=2)........one不可以加引号
6. dict.fromkeys(‘hello’,[])................hello中的每个字母为键,l只生成1个,[]内所有的都为值,哪怕有很多元素
7.删除字典 del d .........d为字典
8.字典元素的值访问 eg. person={‘name’:’name’,’age’:12,’habit’:[‘tiaowu’,’changge’]}
(1)通过key来打印值: print(person[‘name’])...........如果name不存在就会报错
(2)通过get: print(person.get(‘age’,’good’))........如果age不存在就会得None,如果还有其他元素就打印下一个元素比如good
(这段代码定义了一个名为person的字典，其中包含了一个人的姓名、年龄和爱好信息。然后使用print函数输出了字典中键为'age'的值。
person.get('age', 'good')是一个字典的方法调用。get()方法用于获取字典中指定键的值，如果该键不存在，则返回第二个参数作为默认值。在这里，键'age'存在于person字典中，其对应的值为12，所以输出结果为12。
如果将代码改为print(person.get('gender', 'unknown'))，则输出结果将是unknown，因为键'gender'不存在于person字典中。
)
9.访问字典中的键值对
(1)item
eg. print(person.item())...............访问字典的所有键值对
(2)keys
eg.print(person.keys())...............访问字典的所有键
(3)values
eg.print(person.values())...............访问字典的所有值
10.修改字典
(1)赋值:给存在的键赋值则是修改
eg. person[‘name’]=’lisi’
print(person)
(2)添加①:给不存在的键赋值则是添加
eg.person[‘gender’]=’male’
(3)添加②:
eg.person.setdefault(‘name’,’lisi’)............存在就打印本身且不会修改,不存在就添加
(4)添加③(可以添加多个元素):
eg.person.update({‘name’:’lisi’,’gender’:’male’,’math’:’100’})蓝色部分是不存在的,就是添加,同时可以修改name
(5)删除①
del person[‘name’]..........指定删除的键
(6)删除②
eg.person.pop(‘name’).............先返回值,再删除,如果删除的键不在字典就会报错
(7)删除③
eg. person.popitem()................从最后一个开始删,删 键值对 整体,并以元组的形式返回,如果对空字典使用,就会报错
11.字典的访问
①(1)in可以判断键不可以判断值(此方法为最优解)
eg.person={'name':'zhangsan','age':13,'English':15}
print('zhangsan' in person)
(2)for i in person:
print(i,person[i])......................只有i那只能得到键
(3)for i,j in person.items():
print(i,j)..................................................两个字母来接受可以和(2)结果一样
(4)for i in person.keys():
print(i,person[i])
(注:可以得到值和键)
②(1)for i in person.values()
print(i)......................................................只能得到值
十一.集合
1.特点:无序,可变,使用大括号,同一个集合元素不重复,元素(本身可变)为不可变类型,不能是列表和字典(可以是数字,元组,字符串)
2.作用:去重,关系运算
3.集合的创建和删除
eg.(1)a={1,2,3,4,5,6,1,2,3}
print(len(a)) 结果为6
(2)b=set(‘hello’)
print(b)
print({1,8,0,4}=={8,0,4,1}) 结果是True即集合无序
4.集合元素的添加和删除(列表不可以使用add)
(1)添加
a={1,2,3,4}
a.add(‘hello’)
print(a)
(2)删除①
a={1,2,3,4}
print(a.pop())..........................随机删除,中间不填参数
(3)删除②
a={1,2,3,4}
a.remove(2)............................指定删除
print(a)
(4)删除③
a={1,2,3,4}
a.discard(2)............................当删除元素不在集合时discard不报错,remove报错
print(a)
5.集合的运算
(1)并集
a={1,2,3,4,5,6}
b={10,20,30,40,50,60}
print(a | b)
或者print(a.union(b))...........................直接update就可以更新
(2)交集
a={1,2,3,4,5,6}
b={10,20,30,40,50,60}
print(a & b)
或者print(a.intersection(b))..............a.intersection_update(方法等于 a&=b)是用交集替换原来的,若用原来的方法是不改变a,b,更新那个就把那个放前面如: b.intersection_update
(3)差集
a={1,2,3,4,5,6}
b={10,20,30,40,50,60}
print(a-b)....................................................即a减去a交b
或者print(a.difference(b))..............a.difference_update(方法等于 a-=b)是用差集替换原来的,若用原来的方法是不改变a,b
(4)对称差集 对称差集是指两个集合A和B的所有元素中，除了它们的交集之外的所有元素的集合
a={1,2,3,4,5,6}
b={10,20,30,40,50,60}
print(a^b)
或者print(a.symmetric_difference(b))..............a.symmetric_difference_update
6.集合的关系判断
(1)判断是否相等 == !=
(2)判断集合包含关系:
a={1,2,3,4,5,6}
b={10,20,30,40,50,60}
print(a.issubet(b)).................判断a是不是b的子集
print(a.issuperset(b)).................判断a是不是b的超集
(3)集合生成式
x={i for i in range(100)}
print(x)
十二.格式化打印字符串
1.使用格式化运算符%(在字符串中)
(注:%f浮点数,%s字符串类型,%d十进制数,%f默认6位小数,%f.2就是2位小数)
eg.
print(‘大家好,我的名字是%s,我今年%d岁了,身高%f’%(name,age,height))按顺序替换
2.(1)字符串format方法 {}占位
print(‘大家好,我的名字是{},我今年{}岁了,身高{}’.format(name,age,height))
(2)可以使用数字关系对应,此时name,age,height顺序可以更改,但是不能有空白字段
print(‘大家好,我的名字是{1},我今年{2}岁了,身高{0}’.format(height,name,age))
(3)还可以
print(‘大家好,我的名字是{n},我今年{a}岁了,身高{h}’.format(h=height,n=name,a=age))
(4)注:此时也可以空白字段对应
print(‘大家好,我的名字是{n},我今年{a}岁了,身高{}’.format(height,n=name,a=age))
但是如下错误,因为空白字段处不能放在后面,所以应该挪到前面
print(‘大家好,我的名字是{n},我今年{}岁了,身高{h}’.format(h=height,n=name,age))
3.列表时
d=[‘zhangsan’,18,’上海’,180]
b=‘大家好,我是{},我今年{}岁了,我来自{}’.format(*d).......此处*是分配的功能
print(b)
4.字典时
info={‘name’:’tom’,’age’:23,’addr’:’北京’,’height’:190}
b=‘大家好,我是{name},我今年{age}岁了,我来自{addr}’.format(**info)............2个*
5.
int(f’大家好,我是{name[::5]},我今年{age+100}岁了,我来自{addr}’)
此时写f后就可以直接写上变量名,还可以在{}计算等
十三.字符串
1.修改字符串大小
s3=’tom’
(1)title:将一个字符串中每个单词的首字母大写，并返回一个新的字符串
(2)upper:将字符串中的所有字母转换为大写
(3)lower:将字符串中的所有字母转换为小写
(4)swapcase:将字符串中的大小写字母互相转换
eg.
my_string = "Hello, World!"
swapped_string = my_string.swapcase()
print(swapped_string) # 输出: hELLO, wORLD!
2.对齐和空格的处理
s=’tom’ b=’ he lo ’
(1)左对齐:print(s.ljust(20,’+’))..........20是长度,默认填充是空格,+是更改填充,填充只能一个字符
(2)右对齐:print(s.rjust(20,’+’))
(3)居中:print(s.center(20,’+’))
(4)去除左右空格:print(b.strip())
(5)去除左空格:print(b.lstrip())
(6)去除右空格:print(b.rstrip(‘d’))
.......................写在括号的就是删除括号内的内容
rint(b.rstrip('d')) 的作用是删除字符串 b 结尾处的所有字符 'd'。
3.分割
x=’zhangsan \r\n \thenry\nmerry jack tony’
注:空白字符:\t \n \r \v \f
(1)print(x.split(‘_’,3)).........从左往右分割,遇见空白字符就分割,’_’是遇见小横线分割,3是最大分割次数,默认最大分割次数就是无穷,结果是列表
(2)print(x.rsplit(‘_’,3)).........从右往左分割,结果是列表
(3)print(x.partition(‘_’)).........从左往右分割,结果是元组,且只有三个元素,分隔符本身会作为一部分,S's存在,就会分为前面两个空字符串,后面是剩余的元素
4.拼接字符串
a=’hello’ b=’world’ fruits=[‘apple’,’hao’,’nang’]
(1)print(a+b)
(2)print(’hello’’world’)............直接 注：不是双引号
(3)①print(‘+’.join(fruits)).........................join前面是连接的字符串,(),[]都可以,因为fruits是列表
②print(‘+’.join([s1,s2]))......s1,s2变成列表,(),[]都可以
(4)print(‘%s+%s’%(s1,s2))
(5)print(‘{}{}’.format(s1,s2))
(6)print(f’{s1}{s2}’)
5.字符串判断
(1)startwith:print(y.startwith(‘z’))........................判断y是不是z开头,返回布尔值
(2)endswith:print(y.endswith(‘z’))........................判断y是不是z结尾,返回布尔值
注:实际上，endswith() 函数判断的是字符串的后缀是否匹配，而不是完全相等。如果字符串的最后几个字符与指定的后缀匹配，则返回 True，否则返回 False
(3)isalpha:print(y.isalpha())..........判断前面的字符串是否全为字母,空格不是字母,返回布尔值
(4)isdigit:print(‘3.14’.isdigit()).........判断前面的字符串是否全为数字,.不是字母,返回布尔值
(5)isspace:print(‘\n\t’.isspace()).........判断前面的字符串是否全为空白字符
6.字符串的查找与替换
①查找
(1)find:print(b.find(‘ll’))...............从左向右返回子串在字符串中的位置,返回-1是没有找到
这行代码使用了字符串的find()方法，用于查找指定子串在字符串中第一次出现的位置。
(2)rfind:print(b.rfind(‘l’))...............从右向左返回子串在字符串中的位置
(3)index:print(b.index(‘l’))..........没找到就会报错.
②替换
b=’hello,python world’
c=’this is a text’
(1)单个替换:
print(c.replace(‘s’,’l’,1))............s替换为l,1是替换次数,不写就是全部替换
(2)多个替换:
x=str.maketrans(‘sti’,’zwo’,’a’)....建立映射表,s映射z,t映射w等等,结果是字典类型,一一对应.第三个参数就是去掉该参数
print(c.translate(x))
注:上面两行代码一起使用
十四.函数(函数括号不能少,表示调用)
1.函数格式
eg.(1)定义
def tell_story():
print(1)
(2)使用
for i in range(0,5)
tell_story()
2.函数文档:
(1)三引号注释可以存在函数中,可以被打印出来,# 注释没办法打印
(2)print(tell_story.__doc__)................函数.__doc__就是访问函数文档
3.部分函数
(1)跨文档使用定义函数(使用的文件命名规范)
from a(文件命) import tell_story(导入的函数)
(2)if __name__==’__main__’:
tell_story()
这段代码的作用是从名为 "a" 的文件中导入函数 "tell_story" 并在程序运行时执行该函数。
其中，if __name__ == '__main__': 表示当该模块被直接运行时，才会执行下面的代码，而当该模块被导入时，不会执行下面的代码。
因此，如果在命令行中运行该脚本，将会执行 tell_story() 函数。而如果该脚本被其他脚本导入，那么 tell_story() 函数不会被执行。
eg.
import func................导入文件
func.printNumLine..........func文件中的printNumLine函数
4.函数的调用
(1)def test1():
print(1)
def test2():
print(2)
test2().............................此处是调用函数,如果使用print,就print(test()),此处要有().
5.callable函数
print(callable(test2))..............判断一个对象是否可调用（即是否可以像函数一样被调用）
6.函数的参数(定义函数位置参数是必需的，因为它们提供了执行函数所需的数据)
(1)def date(year,month=’01’,day=’01’).....函数定义时,month,day是默认形参
print(year,month,day)
date(2023)..........2023是位置实参,2023传入year,month,day会传入,打印结果是2023 01 01
(2)如果date(2023,11,23)也没有问题
(3)如果def date(year,month=’01’,day=’01’)
a=month.title()
print(year,month,day)
date(2023,11,23)
会报错,因为a=month.title()是字符串类型
(4)date=(2023,day=23)
(5)默认形参在非默认形参后面,位置实参写在关键字实参前面
eg.
def f(b,a=0)
(6)默认行参只在函数定义时计算一次
(7)①默认形参,可变对象会改变
eg.
def f(var, arr=[]): .............var是位置形参
arr.append(var)
return arr
print(f(1)) # 输出 [1]
print(f(2)) # 输出 [1, 2]
②以上代码我希望print(f(2)) # 输出 [ 2]
eg.
def f(var, arr=None):
if arr is None:
arr = []
arr.append(var)
return arr
print(f(1)) # 输出 [1]
print(f(2)) # 输出 [2]
(8)关键字实参
eg.
def greet(name, age):
print("Hello", name)
print("You are", age, "years old.")
# 使用关键字实参调用函数
greet(name="Alice", age=25)
(9)全局变量
①局部变量(作用只在函数内部)与全局变量相同,函数内部优先使用局部变量
②区别:
# 全局变量
global_var = "I am a global variable"
def my_function():
# 局部变量
local_var = "I am a local variable"
print(local_var)
print(global_var)
my_function()
print(global_var)
③在函数内部修改局部变量的值会默认其为局部变量, 若此时内部没有相应的局部变量就会报错,并不会使用全局变量,所以使用global
eg.
count = 0 # 全局变量
def increment():
global count # 使用global关键字声明要在函数内部使用的全局变量
count += 1
increment()
print_count()
7.内置函数
(1)locals(): 返回表示当前局部作用域的字典，其中包含了当前作用域中的所有局部变量。globals(): 返回表示全局作用域的字典，其中包含了全局作用域中的所有全局变量。这两个函数通常用于调试和动态查看变量
eg.
print(‘locals={},globals={}’.format(locals(), globals()))
或
global_var = "I am a global variable"
def my_function():
local_var = "I am a local variable"
print('Local variables:', locals()) # 打印当前作用域的局部变量
print('Global variables:', globals()) # 打印全局作用域的全局变量
my_function()
(2)形参和实参
def greet(name):
print("Hello, " + name + "!")
greet("Alice")
在上述代码中，name 是 greet() 函数的形参，它表示一个名称。当我们调用 greet("Alice") 时，"Alice" 就是实参，它实际上被传递给 name 形参，函数将使用该实参打印出相应的问候语。
(3)如果函数有return就可以x=……,print(x),如果函数内有print就不需要额外加print如果只是return就要加print
(4)return的作用返回值给函数,结束函数执行.只能返回一个值,多个值的情况就是元组格式 return(),也可以是列表return[].
(5)test:在一般的情况下，test 不是 Python 内置函数或语句，因此没有一个固定的作用。通常情况下，test 是一个函数名或变量名，其作用根据程序设计者的意图而定。
8.可变长度参数
(1)eg.
def add_many(a,*args,b):
print(a)
print(*args)
print(b)
add_many(10,20,30,40,50)...........10先给a,不传就是空元组.
注:此时50不会给b因为*arg全部获取.所以50改为b=50.**就是字典
9.arg=[3,7]
s=list((range(*args)))...................此处*是分配的作用
注:对于函数定义中的参数，星号 * 可以具有不同的含义，这取决于它的使用方式。下面是两种常见的用法：
①函数定义时的参数收集：当星号 * 用于函数定义时，它可以用来收集任意数量的位置参数。这样的参数被收集到一个元组中，并在函数体内以元组的形式进行访问。这种用法通常用于定义可变长度参数。
②函数调用时的参数分配：当星号 * 用于函数调用时，它可以将一个可迭代对象（如列表、元组等）解包成独立的位置参数。这样的参数分配可以在函数调用时方便地传递多个参数。
10.(1)递归函数
eg.①1加到n
def f(n):
if n==1:
return 1
return f(n-1)+n
print(f(10))
②斐波那契数
def f(n):
if n == 1 or n == 2:
return 1
return f(n-1) + f(n-2)
result = f(10)
print(result)
(2)匿名函数:定义简单的单行函数
方式一:mul=lambda a,b=3:a*b ................:前是参数,后是表达式
print(mul(3,b=10))
方式二:
print(sorted(alist,key=lambda x:abs(x)))
十五.Unicode及文件相关常识
1.编码基本知识:UTF-16使用16位（2个字节）固定长度编码每个字符，而UTF-8使用8位（1个字节）到32位（4个字节）不等的变长编码
eg.
①编码
name=’张三’
data=name.encode(‘utf-8’)
print(data)
print(type(data))
②解码
res=data.decode(‘utf-8’)
print(res)
(注:以什么方式编码就以什么方式解码,比如都是utf-8)
2.打开文件等(流程:打开文件后,读取,最后关闭)
(1).打开文件
f=open(file,mode,encoding).................file：要打开的文件路径或文件名,mode：打开文件的模式,encoding：指定文件编码方式的参数，用于读取和写入文件时的字符编码
(注:(1)在同一路径下,可以用相对路径打开文件,不在同一路径，用绝对路径(2)./ 当前文件(3)../ 上一级文件夹)
(2).打开文件
file_object=open(‘t3.txt’,mode=’r’).......文本形式但不可以修改
file_object=open(‘t3.txt’,mode=’wt’).......文本形式但可以修改
file_object=open(‘图片.png’,mode=’rb’).......图片形式
注:mode=’r’是只读
(3).判断文件是否存在
import os
exists=os.path.exists(‘xxx.txt’)
print(exists)
(4)读取文件
data=file_object.read()...........不可以修改
file_object.write(f)......可以修改
(5)关闭文件
file_object.close()
(6)实例
file_object=open(‘t1.txt’,mode=’wb’)
f=’hello,python’.encode(‘utf8’)
file_object.write(f)...........此处f以utf8才能直接开始
file_object.close()
解释:
总结起来，你的代码打开了一个文件 't1.txt'，将字符串 'hello,python' 转换为字节对象，并将其写入到该文件中，然后关闭了文件。这样就完成了将字节数据写入文件的操作
3.模式
(1)r,rt,rb:只读
(2)w,wt,wb:只写
(3)x,xt,xb:只写,不存在就创建,存在报错
(4)a,at,ab:只写,存在尾部追加,不存在就创建
(5)r+,rb+:既可以读又可以写
4.读,会接着前面的继续读
①
data=file_object.read(10)..........10是读10个元素,换行符也算1个
print(data)
②
l1=file_object.readline()..........读取一行
l2=file_object.readline()
print(l1)
print(l2)
③
data_list=file_object.readlines()....readlines() 方法用于读取文件中的所有行,注意,每个字符串元素都保留了行末尾的换行符
print(data_list)............................元素会加入列表
④
for line in file_object:
print(line.strip)
5.上下文管理语句
(1)可以自动关闭文件,异常报错也会自动关闭文件
with open(‘info.txt’,mode=’rb’) as f:
data=f.read()
print(data)
(2)
import sys
sys.stdout=open(‘t2.txt’,’w’,encoding=’utf-8’) ............修改文件输出位置,改变控制台的位置
(3)
import sys
sys.stdout=open(‘t4.txt’,’w’,encoding=’utf-8’)
print(1/0)...............................此时就在t4才报错
十六.面向对象
1.类:一个一个函数组成
(1)定义类
eg.
class Student(): ...................一般类要大写,class Student(object)表继承
(2)创建对象
s1=Student(‘小明’,18,175)
s2=Student(‘小美’,17,165)
a=list(‘hello’)
print(a)
(3)构造函数(固定形式)
def __init__(self,name,age,height):
self.name=name
self.age=age
self.height=height
print(self)............self是对象本身
s1=Student(‘小明’,18,175)
print(s1.name)
给不存在的赋值,则是添加(ed:s1.gender=’male’)
(4)def __del__(self):
print(‘__del__方法被调用了’)
注:①析构方法:删除对象时,会自动调用来释放对象占用的资源,完全删除.
②在 Python 中，当一个对象没有任何引用时，它就会被自动垃圾回收。在对象被销毁之前，Python 会自动调用 __del__ 方法，以便执行必要的清理操作。
例如，当你创建一个对象并将其赋值给变量时，变量引用该对象。如果你删除该变量或程序结束时，该对象就会被垃圾回收。在垃圾回收过程中，Python 会自动调用该对象的 __del__ 方法
(5)__slots__(‘name’,’age’,’height’)
让其只有规定的,无法像上述给不存在的赋值,则是添加
(6)def run(self):
print(‘hello’)
s1.run()........................函数内的self就是s1的元素
(7)函数
①isinstance()
eg.isinstance() 是 Python 内置函数之一，用于检查一个对象是否是指定类或子类的实例
print(isinstance([1,2,3,4,5,6],list))
②issubclass()
eg.issubclass() 是 Python 内置函数之一，用于检查一个类是否是另一个类的子类
print(issubclass(Student, object))
(8)练习
①定义圆形类
from math import pi
class Circle:
def __init__(self, r):
self.r = r
def getPerimeter(self):
return 2 * pi*self.2
def getArea(self):
return pi * self.r **2
c=Circle(10)
print(c.getPerimeter())
print(c.getArea())
②矩形类
class Rectangle:
def __init__(self, length, width):
self.length = length
self.width = width
def area(self):
return self.length * self.width
def perimeter(self):
return 2 * (self.length + self.width)
# 创建一个长度为 5，宽度为 3 的矩形对象
my_rectangle = Rectangle(5, 3)
# 计算矩形的面积
print(my_rectangle.area()) # 输出：15
# 计算矩形的周长
print(my_rectangle.perimeter()) # 输出：16
③一元二次方程类
import math
class Equation:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def calculate_discriminant(self):
return self.b**2 - 4 * self.a * self.c
def calculate_roots(self):
discriminant = self.calculate_discriminant()
if discriminant > 0:
root1 = (-self.b + math.sqrt(discriminant)) / (2 * self.a)
root2 = (-self.b - math.sqrt(discriminant)) / (2 * self.a)
return root1, root2
elif discriminant == 0:
root = -self.b / (2 * self.a)
return root
else:
return None
(9)函数里面的属性叫:对象属性/实例属性,只有具体调用
在类中是:类属性,可以通过类对象和实例对象调用,可以以.的形式调用.如果要修改要用类名.
(10)私有属性是指在类定义中使用双下划线（"__"）作为前缀命名的属性。私有属性的作用是限制对类的属性直接访问，只能通过类内部的方法进行访问和修改
①外部_类名+__私有变量名可以访问(eg:_Person__money)②在类内部，可以通过方法我们定义了一个私有属性 __private_attribute，并在类的构造函数中初始化了它的值。接着，我们定义了一个公有方法 set_private_attribute，用于修改私有属性的值来修改私有属性
1219
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
