本文共 7912 字，大约阅读时间需要 26 分钟。

python 执行的顺序，自上而下顺序执行（面向过程）

概述

计算机是处理数学运算的机器，但是不限于数学运算，比如，图形，音视频，不同的数据，需要定义不通的数据类型

number（数字）

• 整数
• 浮点数（小数）

String（字符串）

布尔值 None（空值） List（列表） tuple（元组） dict（字典） set（集合） 对象

数字类型

• 分类
  整数：python可以处理任意大小的整数，包括负整数，在程序中表示和数学的写法一样

num=10num1=numnum2=num1# 连续定义多个变量，一般不建议，可读性较差num4=num3=num2# 交互式赋值定义变量num5,num6=6,7

可以通过id（num5）查看地址

浮点数（小数）：浮点型由整数部分与小数部分组成，浮点数运算可能会有四舍五入的误差

复数：实数部分与虚数部分构成

• 数字类型转换：如果是字符串，必须是正规数字才可以否则报错

# 浮点型转整型,向下取整,结果是1int(1.5)# 整型转浮点型，结果是1.0float(1)# String型转整型,向下取整,结果是1int("1.5")int("+1.5")# String转浮点型，结果是1.0float("1")# 以下是错误的写法int("abd")float("1abd23")

• 数学功能

# 取绝对值al=-10a2=abs(a1)# 比较两个数的大小a3=100a4=9a5=(a3>a4)-(a3

字符串

字符串是以单引号或双引号扩起来的任意文本

e.g,

str1='abc'str2='def'

字符串运算（字符串是不可变的）

# 字符串连接    str3='Alex is a good '    str4= 'man'    print(str3+str4)    # 输出重复字符串    print(str3*3) # Alex is a good Alex is a good Alex is a good     # 访问字符串中的某一个字符，通过索引下标查找字符,字符串名[下标]    print(str3[1]) # l    str3[1]='b' # 报错，字符串不可变    # 截取字符串中的一部分    print(str3[5:14]) # 从给定下标开始截取，到给定下标结束截止    print(str3[:14]) # 从头截取到规定下标位置    print(str3[4:]) # 从给定下标开始至结束    print('good' in str3) # str3中是否有good，如果有就是true    print('good' not in str3)    print(~5) #    '''    00000101    11111010    10000110    '''    # 格式化输出    num=10    f=10.1    print("num=",num) # 打印两个值    print("num=%d"%(num)) # %d占位符，num替换的内容    print("num=%d,str3=%s,f=%f"%(num,str3,f))    print("Alex is a \'good\' man") # 转移字符    print('''    good    nice    handsome    ''') # 转移的一种，换行    # 字符串中，如果有很多字符都需要转移，就需要加入很多\,为了简化，python允许用r表示内部的字符串默认不转义    # e.g,win的路径C:\Users\xlg\Desktop,以下两种都正确    print("C:\\Users\\xlg\\Desktop")    print(r"C:\Users\xlg\Desktop")

格式化输出

符号	描述
%d	整数（占位符）
%s	字符串（占位符）
%f	浮点数（占位符）
\n	换行
\	转义字符，将一些字符换成有特殊含义的字符
\t	制表符

函数

eval(str), 将字符串str当成有效的表达式来求值并返回计算结果

num1 = eval('123')print(type(num1)) # 
   
    num1 = eval('123+2')print(num1) # 125num1 = eval('-123+1')print(num1) # -122
   

len(str):返回字符串的长度，字符的个数

str.lower():转换字符串中大写字母为小写字母

print("ALL".lower()) # all

upper()，转换字符中的小写字母为大写字母

swapcase()，转换字符串中的小写字母为大写，大写字母为小写 capitalize()，首字母大写，其他小写 titile()，单词的首字母大写 center(width,fullchar)，返回一个指定宽度，居中的的字符串，fullchar为填充的字符，fullchar为空，就用空格填充

str='Alex is a nice man'print(str.center(40,"*")) # ***********Alex is a nice man***********

ljust(width[,fullchar])，同center，左对齐

rjust(width[,fullchar]，同center，右对齐 zfill(width)，返回一个长度为width字符串，原字符串右对齐，前面补0

str="Alex is a good man"print(str.zfill(40))

count(str[,start][,end])，返回str在字符串中出现的次数，范围从start到end，默认全部

find(str[,start][,end])，检测str字符串是否包含在字符串中，范围从start到end，默认全部，得到的是第一次出现的开始下标，没有返回-1 index(str,start=0,end=len(str))，find一样，只不过如果str不存在的时候会报出一个异常 rindex(str,start=0,end=len(str)) rfind(str,start=0,end=len(str)) lstrip()，截掉字符串左侧指定的字符，默认为空格 rstrip()

str='Alex is a good man'print(str.rstrip(),"*")

函数	描述	e.g
split(str[,num])	以分割符截取字符串,截取num个字符串，剩下的就不截了	“alex is a good man”.split(” “)
splitlines(b)	按照(‘\r’,’\r\n’,’\n’)分割，返回行数的列表	-
join()	以指定的字符串分割符，将seq中的所有元素组合成一个字符串
max()
min()
replace(oldstr,newstr,count)	count指定数量，只替换count个
maketrans(keystr,valuestr)	创建一个映射表

求字符串中的单词数量

c=0for i in "alex is a good man".split(" "):    if len(i)>0        c+=1print(c)

按行切割

str='''Alex is a good manAlex 是一个不错的人'''print(str.splitlines())print(str.splitlines(True)) # 会保留换行符

list组合成字符串

list=["Alex","is","a","good","man"]print(" ".join(list)) # Alex is a good man

max(),min(),ASCII进行比较的

字符串替换

# 创建一个字符映射表# g->n# o->c# d->estr=str.maketrans("good","nice") str1="Alex is a good man "str2=str1.translate(str) # Alex is a ncce man

startwith(str[,start=0][end=len(str)])

在给定的范围内判断是否是以给定的字符串开头，如果没有指定范围，默认整个字符串 endwith(str[,start=0][end=len(str)]),类似startwith

str="Alex is a good man"str.startwith("Alex") # True

其他

#  编码，encode(encoding="utf-8",errors="strict"),一般是utf-8,gbkstr="Alex is a nice man"print(str.encode("gbk"))print(type(str)) # byte # 解码,要与编码时的编码格式一致，否则报错str2=str.decode("utf-8")str2=str.decode("utf-8","ignore") # 错误不处理print(str2)# isalpha(),如果字符串中至少有一个字符，且所有的字符都是字母，返回True 否则返回Falsestr3="Alex is a nice man"print(str3.isalpha())# isalnum(),如果字符串中至少有一个字符且所有的字符都是字母或数字返回True，否则返回Falsestr4="2"print(str3.isalnum())# isupper(),如果字符串中至少有一个英文字符且所有的英文字符都是大写的英文字母，返回True，否则Falseprint("ABC".isupper()) #Trueprint("ABC1".isupper()) #Trueprint("1".isupper()) #Falseprint("ABC#".isupper()) #True# islower()，与isupper()相反# istitle(),如果字符串是标题化（单词的首字母大写）的，返回True# isdigit(),如果字符串中只包含数字字符返回Trueprint("1".isdigit()) #Trueprint("1s".isdigit()) #False# isnumeric(),同isdigit()# isdecimal(),字符串中只包含十进制字符# isspace(),如果字符串中只包含空格则返回True，否则返回False

布尔

布尔值只有True，False两种值

字符串比较大小 从第一个字符开始比较，谁的ASCII值大谁就大，如果相等，会比较下一个字符的ASCII的值的大小，那么谁的值大谁就大

print("aac" < "bac")

空值

是python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊值

n = None

列表

创建列表

e.g,

# 值可以是任意值list=[1,2,"a","v"]ages=[19,29,8,18,37]

取值&替换，注意：不能越界

list=[1]  # 取值list=[1]="2" # 替换

判断元素是否在列表中

list=[1,2,3,4]print(1 in list) # True

列表截取

list=[1,2,3,4,5,6]print(list[2:6])print(list[:6])print(list[2:])

二维列表

list=[[],[]]

函数	描述	例子
append	在列表末尾添加新的元素
extend	在末尾一次性追加另一个列表中的多个值
insert	在下标添加一个元素，不覆盖原数据，元数据向后顺延	list.insert(2,[2])
pop	移除列表中指定下标的元素（默认移除最后一个元素），并返回删除的元素	pop(2)
remove	移除列表中的某个元素	remove(3)
clear	清除列表中所有的数据
index(x)	从列表中找出某个值的第一个匹配的索引值	index(value[,3][,5])
len(list)	返回列表个数
max(list)	返回列表最大值
min(list)	返回列表最小值
count(3)	查看元素3在列表中出现的次数
reverse	()倒序
sort()	升序，排序

拷贝

浅拷贝：list27->list28，堆区其实是一个值 深拷贝：内存拷贝，堆区其实是2个值

问题：

list去重？ 元组转成列表？

元组

能用元组就用元组，元组不可变，较为安全

本质：是一种有序集合 特点：

• 与列表非常相似
• 一旦初始化，就不能修改
• 使用小括号

创建元组

# 创建一个空元组tuple1=()print(tuple1)# 创建带有元素的元组，元组中的元素类型可以不同tuple2=(1,2,3,"abc",True)print(tuple2)# 定义只有一个元素的元组tuple3=(1,)print(tuple3)print(type(tuple3))

元素元组的访问

格式

tuple4=(1,2,3,4,5)print(tuple4[0]) # 下标从0开始，下标超过返回，就越界print(tuple4[-1]) # 获取最后一个元素print(tuple4[-6]) # 越界

修改元组

tuple5=(1,2,3,4,5)tuple5[0]=100  # 报错，元组不能变print(tuple5)tuple6=(1,2,3,4,[5,6,7])tuple6[-1][0]=100  #  元素里面的list可变print(tuple6)

删除元组

tuple6=(1,2,3)del tuple6print(tuple6) # 报错，已经删除

元组的操作

t7=(1,2,3)t8=(4,5,6)print(t7+t8) # 生成新的元组print(t7,t8)# 元组重复t10=(1,2,3)print(t10*3)print(4 in t10)

元组的截取

格式：元组名[开始下标 ,结束下标]

t12=(1,2,3,4,5,6,7,8,9)print(t12[3:7]) # [3,7)print(t12[3:])print(t12[:7])

二维元组:元素为一维元组

tuple=((1,2,3),4,5,6)tuple[0][1]  # 取出来的是2

元组的方法

函数	描述
len(tuple)	返回元组中的元素个数
max(tuple)	返回元组中的最大值
min(tuple)	返回元组中的最小值

将列表转成元组

list=[1,2,3]t=tuple(list)

元组遍历

for i in (1,2,3):    print(i)

字典

概述

使用键-值（key,value）存储，具有极快的查找速度，字典是无顺序的 key的特性： 字典中的key必须唯一 key必须是不可变的对象 字符串，整数等都是不可变的，可以作为key list是可变的，不能作为key，一般用str作为key 思考：保存多位学生的姓名与成绩

dict={
  "Jack":90,"Alex":100}# 元素的访问, 获取：字典[key]print(dict["Alex"]) # 100print(dict["Lucy"]) # ，不存在，报错if ret==None:    print("no")else:    print("have")# 添加dict["Lilei"]=99 # 添加dict["Alex"]=90 # 覆盖# 删除dict.pop("Alex")# 遍历for key in dict: # 取出key    print(key,dict[key])for value in dict.values(): # 取出values    print(value)# dict.items() 取出元组列表for key,value in dict.items(): # 取出values    print(key,value)# 有编号的输出，但是字端是无顺序的for i,v2 in enumerate(dict): #排顺序，按照存的顺序    print(i,v2)

和list的比较：

1. 查找和插入的速度极快，不会随着key-value的增加而变慢
2. 需要占用大量的内存，内存浪费多

list

1. 查找和插入的速度会随着数据量的增多而减慢
2. 占用空间小，浪费的内存少

问题：统计一个字符中的每个单词个数？

str="Alex is a good man"

set

类似dict，是一组key的集合，不存储value

本质：无序和无重复元素的集合 创建set需要一个list或者tuple或者dict作为输入集合

s1=set([1,2,3,4])print(type(s1))s2=set((1,2))print(s2)s3=set({
  1:"good"})print(s3)s4=set([1,2])s4.add(3)print(s4)s3.add(3)print(s4)# 插入整个list，tuple，字符串，打碎插入s5=set([1,2])s5.update([5,6,7])# 删除s5.remove(3)# 遍历for i in s5:    print(i)s7=set("asd")for i in s7:    print(i) # 无顺序，也没有索引for index,data in enumerate(s7):    print(index,data)# 交集 & 并集 # 交集 a1 = s8 & s9 # 并集 a2 = s8 | s9# set->lists3={
  1,2,3,4}l3=list(s3)#set -> tuples4={
  2,3,4}t4=tuple(s4)

重复元素在set中会自动被过滤，可以添加重复的，但是无效的

set的元素不能是dict set转字典

迭代器

可迭代对象：可以直接作用域for循环的对象统称为可迭代对象（Iterable），可以用isinsrance（）去判断以下是否是Iterable对象,可以直接作用于for循环的数据类型的一般分两种 1，集合数据类型，入list，tuple，dict，set，string 2，是generator，包括生成器和带yield的generator function

print(isinstance([],Iteranle))print(isinstance("",Iteranle))

迭代器不仅可以作用于for循环，还可以被next（）函数不断调用并返回下一级，直到最后跑出一个StopIteration错误表示无法继续返回下一个值

可以被next()函数调用并不断返回下一个值的对象成为迭代器（Iterable）