目录
字符串
转化
ord()将字符转化为Unicode码
chr()将Unicode码转化为字符
创建
用''或“”创建单行字符串
a='asd' a="asd"
用三个单引号或者三个双引号创建多行字符串
a='''name="a" age=18 score=100'''
可用空字符串
b=''
用len()查阅字符串长度
d=len(a)
转义字符
\\ #反斜杠 \' #单引号 \" #双引号 \b #退格 \n #换行 \t #横向制表符 \r #回车
字符串的操作
字符串的拼接
用加法或直接放到一起
"aa"+"bb" "aa""bb"
字符串的复制
用乘法
"ab"*3
数字转型字符串
用str()将数据类型转化为字符串
str(5.20)
提取字符
用[]来提取字符
a[0] #a的第一个字符 a[-1] #a的最后一个字符
字符串的替换
用replace()来实现字符串的替换
a="asdzxcqwe"
a.replace("c","z")
#asdzxzqwe
a
#asdzxcqwe
字符串切片
| 操作与说明 | 示例 | 结果 |
|---|---|---|
| 提取整个字符串[:] | "asdzxc"[:] | asdzxc |
| 从start索引开始到结尾[start:] | "asdzxc"[3:] | zxc |
| 从头开始到end-1[:end] | "asdzxc"[:3] | as |
| 从start到end-1[start:end] | "asdzxc"[3:5] | zx |
| 从start到end-1，步长为step[start: end : step] | "asdzxc"[1:5:2] | sz |
| 倒数三个[-3:] | "asdzxc"[-3:] | zxc |
| 倒数第八个到倒数第三个[-8:-3] | "asdzxcqwe"[-8:-3] | sdzxc |
| 从右往左输出[::-1] | "asdzxc"[::-1] | cxzdsa |
字符串的分割
用split()来进行分割
a="to be or not to be"
a.split()
#['to','be','or','not','to','be']
a.split('be')
#['to','or not to','']
字符串的合并
用join()来进行合并
a=['asd','zxc','qwe'] '*'.join(a) #'asd*zxc*qwe' ''.join(a) #'asdzxcqwe'
常用查找方法
len(a) #字符串长度
a.startwith('a') #判断是否以'a'开头
a.endwith('a') #判断是否以'a'结尾
a.fine('a') #寻找'a'第一次出现的位置
a.rfind('a') #寻找'a'最后一次出现的位置
a.count('a') #寻找'a'在字符串中出现次数
a.isalnum() #判断所有字符是不是都是字母或数字
去除首尾信息
"*a*b*c*".strip("*") #'a*b*c'
"*a*b*c*".lstrip("*") #'a*b*c*'
"*a*b*c*".rstrip("*") #'*a*b*c'
" abc ".strip() #'abc'
大小写转换
a.capitalize() #产生新的字符串，首字母大写 a.title() #产生新的字符串，每个单词首字母大写 a.upper() #产生新的字符串，每个字母都大写 a.lower() #产生新的字符串，每个字母都小写 a.swapcase() #产生新的字符串，每个字母大小写转换
格式排版
可用center(),ljust(),rjust()进行排版
a="asd" a.center(9,"*") #'***asd***' a.center(9) #' asd ' a.ljust(9,"*") #'asd******'
其他操作
a.isalnum() #判断是否为字母或数字 a.isalpha() #判断是否只有字母（包括汉字） a.isdigit() #判断是否只有数字 a.isspace() #判断是否为空白符 a.isupper() #判断是否为大写字母 a.islower() #判断是否为小写字母
不换行打印
print("asd",end='')
print("asd",end='##')
输入字符串
用Input（）
myname=input("请输入你的名字：")
字符串的格式化
用format()进行对字符串的格式化
填充与对齐
^ < >分别对应居中对齐、左对齐以及右对齐，后面跟宽度,前跟填充的字符，：后跟填充字符
"{:*>8}".format("245")
#'*****245'
"{:*<8}".format("245")
#'245*****'
"{:*^9}".format("245")
#'***245***'
可变字符串
可用io.StringIO对象或者array模块。
import io
a="hello,boy"
sio=io.StringIO(a)
sio
#<_io.StringIO object at ……>
sio.getvalue()
#'hello,boy'
sio.seek(7)
#7
sio.write("g")
#1
sio.getvalue()
#'hello,goy'
运算符
| and or not | 与 或 非 |
|---|---|
| | | 按位或（2进制） |
| >> | 右移一位=除以2 |
| << | 左移一位=乘以2 |
| & | 按位与（2进制） |
| ^ | 按位异或（2进制中不相同即为1） |
列表
列表的操作表
| 方法 | 要点 | 描述 |
|---|---|---|
| list.append(x) | 增加元素 | 将x加入到List的尾部 |
| list.extend(alist) | 增加元素 | 将alist的元素加到list的尾部 |
| list.insert(index,x) | 增加元素 | 在List的index位置插入x |
| list.remove(x) | 删除元素 | 删除在list中首次出现的x |
| list.pop([index]) | 删除元素 | 删除并返回列表list指定为止的index处的元素，默认是最后一个元素 |
| list.clear | 删除所有元素 | 删除所有元素 |
| list.index(x) | 访问元素 | 返回第一个x的索引位置 |
| list.count(x) | 计数 | 返回x在list出现的次数 |
| len(list) | 列表长度 | 返回列表长度 |
| list.reverse() | 翻转列表 | 所有元素翻转 |
| list.sort() | 排序 | 所有元素排序 |
| list.copy() | 浅拷贝 | 返回列表对象的浅拷贝 |
列表的创建
1.直接创建
a=[20,30,40,"asd"] a[0] #20 a[3] #'asd'
a=[] a.append(20) a #[20]
2.list()
a=list()
a
#[]
a=list("asd")
a
#['a','s','d']
a=list(range(10))
a
#[0,1,2,3,4,5,6,7,8,9]
3.range()
range(start,end,step)
start——起始值，end——终止值（到前一位），step——步长
list(range(1,20,2)) #[1,3,5,7,9,11,13,15,17,19]
4.推导式生成列表
a=[x*2 for x in range(5)] a #[0,2,4,6,8] a=[x*2 for x in range(100) if x % 9 == 0] a #[0,18,36,54,72,90,108,126,144,162,180,198]
列表元素的增加与删除
元素添加
append（）
a=[20,40] a.append(80) a #[20,40,80]
速度最快，在列表最后添加，推荐使用。
+运算符
a=[20,40] a=a+[50] a #[20,40,50]
创建新的列表对象，对于大量元素不推荐使用。
extend（）
a=[20,40] a.extend([50,60]) a #[20,40,50,60]
将目标所有元素添加到此列表尾部 ，不创建新的列表对象。
insert（）
a=[10,20,30] a.insert(2,100) a #[10,20,100,30]
将指定元素插入指定位置，会使插入位置后面的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。
乘法拓展
a=['sxt',100] b=a*3 a #['sxt',100] b #['sxt',100,'sxt',100,'sxt',100]
生成一个新列表，为原列表元素的多次重复。
元素删除
del删除
a=[10,20,30] del a[1] a #[10,30]
删除指定位置的元素。
pop()
a=[10,20,30,40,50] a.pop() #50 a #[10,20,30,40] a.pop(1) #20 a #[10,30,40]
删除并返回指定位置元素，未指定位置则默认最后一位。
remove()
a=[1,2,3,4,5,6,1,2,3] a.remove(2) a #[1,3,4,5,6,1,2,3] a.remove(10) #Traceback (most recent call last): # File "D:\python文件\速成班.py", line 5, in <module> # a.remove(10) #ValueError: list.remove(x): x not in list
删除首次出现的指定元素，若不存在则异常。
列表元素的访问与计数
通过索引直接访问元素
a=[1,2,3,4,5] a[1] #2 a[5] #Traceback (most recent call last): # File "D:\python文件\速成班.py", line 4, in <module> # a[5] #IndexError: list index out of range
index()获取指定元素在列表中首次出现的索引
index()用法：index(value,[start,[end]])，其中start与end规定了搜索的范围。
a=[1,2,3,4,5,1,2,3,4,5] a.index(2) #1 a.index(2,3) #6
count()获得指定元素在列表中出现的次数
a=[1,2,3,4,5,1,2,1,3,4,5] a.count(1) #3 a.count(2) #2
len()获取列表长度
a=[1,2,3,4,5] len(a) #5
成员资格判断
用In或count()判断
a=[1,2,3,4,5,6] 1 in a #True 8 in a #False
列表的切片操作
标准格式为：[起始偏移量start:终止偏移量end[:步长step]]
操作表
设a为[1,2,3]
b为[1,2,3,4,5,6,7]
| 操作和说明 | 示例 | 结果 |
|---|---|---|
| [:]提取整个列表 | a[:] | [1,2,3] |
| [start:]从start开始到最后 | a[1:] | [2,3] |
| [:end]从头开始到end-1 | a[:2] | [1,2] |
| [start:end]从start开始到end-1 | a[1:3] | [2,3] |
| [start:end;step]从start开始到end-1，步长为step | b[1:6:2] | [2,4,6] |
| [-start:]倒数start个 | b[-3:] | [5,6,7] |
| [-start:-end]倒数第start个到倒数第end-1个 | b[-5:-3] | [3,4] |
| [::-end]步长为-end，从右往左取 | b[::-1] | [7,6,5,4,3,2,1] |
列表的遍历
listObj=[1,2,3,'a','b','c'] for obj in listObj: print(obj) #1 #2 #3 #a #b #c
列表的排序
修改原列表，不建立新列表
a=[2,1,5,3,4] a.sort() #默认是升序排序 print(a) #[1,2,3,4,5] a.sort(reverse=True) print(a) #[5,4,3,2,1] import random random.shuffle(a) #打乱顺序 print(a) #[1, 4, 5, 3, 2]
新建列表的排序
可以通过内置函数sorted()进行排序
a=[2,3,1,4] b=sorted(a) print(b) #[1,2,3,4] print(a) #[2,3,1,4] c=sorted(a,reverse=True) print(c) #[4,3,2,1]
reversed()返回迭代器
reversed()为逆序输出，迭代器只能用一次。
a=[2,1,3,4] c=reversed(a) print(c) #<list_reverseiterator object at 0x000001AF8A818F10> print(list(c)) #[4, 3, 1, 2] print(list(c)) #[]
列表相关的其他内置函数
max与min
返回列表的最大/最小值
a=[1,5,8,2,4,9] print(max(a)) #9 print(min(a)) #1
sum
对数值型列表进行求和
a=[1,3,2,4,5] print(sum(a)) #15
多维列表
二维列表
a=[ ["a",1,4,"d"], ["b",2,5,"e"], ["c",3,6,"f"] ]
元组 tuple
元组属于不可变序列，因此没有增加、修改、删除元素等方法。
元组的创建与删除
1.通过（）创建元组，（）可省略
a=(1) print(type(a)) #<class'int'> a=(1,2,3,4) print(type(a)) #<class'tuple'> a=1,2,3,4 print(type(a)) #<class'tuple'>
2.通过tuple()创建元组
tuple(可迭代对象)
b=tuple()
print(type(b))
print(b)
b=tuple("abc")
print(type(b))
print(b)
b=tuple(range(3))
print(type(b))
print(b)
b=tuple([2,3,4])
print(type(b))
print(b)
'''
<class 'tuple'>
()
<class 'tuple'>
('a', 'b', 'c')
<class 'tuple'>
(0, 1, 2)
<class 'tuple'>
(2, 3, 4)
'''
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组；
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
3.生成器推导式创建元组
生成器推导式创建元组与列表推导式相似，而生成器推导式只能使用小括号，输出结果为生成器对象。
s=(x*2 for x in range(5)) print(s) print(tuple(s)) print(list(s)) print(s) ''' <generator object <genexpr> at 0x000001745141FF90> (0, 2, 4, 6, 8) [] <generator object <genexpr> at 0x000001745141FF90> '''
print(tuple(s)) s=(x*2 for x in range(5)) print(s.__next__()) print(s.__next__()) print(s.__next__()) ''' () 0 2 4 '''
4.通过del完成元组的删除
del b
元组的操作（同列表）
1.索引访问
2.切片操作
3.连接操作
4.成员关系操作 （in）
5.比较运算操作
6.计数：长度、最大/小值、求和
7.排序
只能通过sorted()将元组排序后变为列表。
zip
zip(列表1，列表2，……)可以将多个列表对应位置的元素组合成为元组，并返回zip对象。
a=[1,2,3] b=[4,5,6] c=[7,8,9] d=zip(a,b,c) print(list(d)) #[(1,4,7),(2,5,8),(3,6,9)]
字典
字典是“键值对”的无序可变序列，包括“键对象”和“值对象”。“键”不能重复，而“值”能重复。
字典的创建
1.可通过{}或者dict()来创建字典对象。
a={'name':'asd','age':18,'job':'programmer'}
print(a)
b=dict(name='asd',age=18,job='programmer')
print(b)
a=dict([("name","asd"),("age",18)])
print(a)
c={} #空的字典对象
print(c)
d=dict()#空的字典对象
print(d)
'''
{'name': 'asd', 'age': 18, 'job': 'programmer'}
{'name': 'asd', 'age': 18, 'job': 'programmer'}
{'name': 'asd', 'age': 18}
{}
{}
'''
2.通过zip()创建字典对象
k=['name','age','job']
v=['asd',18,'programmer']
d=dict(zip(k,v))
print(d)
#{'name': 'asd', 'age': 18, 'job': 'programmer'}
3.通过fromkeys创建值为空的字典
a=dict.fromkeys(['name','age','job'])
字典元素的访问
a={'name':'asd','age':18,'job':'programmer'}
1.通过[键]获得值
print(a['name']) #asd print(a['age']) #18
2.通过get()获得值
推荐使用。优点：指定键不存在，则返回None，也可以指定键不存在时返回的对象。
a.get('name')
#asd
a.get('sex','man')
#man
3.列出所有的键值对
print(a.items())
dict_items([('name', 'asd'), ('age', 18), ('job', 'programmer')])
4.列出所有的键，列出所有的值
print(a.keys()) print(a.values()) ''' dict_keys(['name', 'age', 'job']) dict_values(['asd', 18, 'programmer']) '''
5.len()键值对的个数
6.检测一个“键”是否存在于字典中
print("name" in a)
#True
字典元素的添加、修改与删除
a={'name':'asd','age':18,'job':'programmer'}
1.增加/修改键值对
a['address']='zxc' print(a['address']) print(a['name']) a['name']='zxc' print(a['name']) ''' zxc asd zxc '''
2.update()
update()可将新字典中的所有键值对全部添加到旧字典对象上。
a={'name':'asd','age':18,'job':'pro'}
b={'name':'zxc','sex':'male','money':1000}
a.update(b)
print(a)
#{'name': 'zxc', 'age': 18, 'job': 'pro', 'sex': 'male', 'money': 1000}
3.元素的删除
1.del()删除元素
2.clear()清空所有
3.pop()删除指定键值对，并返回“值对象”
a={'name':'asd','age':18,'job':'pro'}
del(a['name'])
print(a)
b=a.pop('age')
print(b)
print(a)
a.clear()
print(a)
'''
{'age': 18, 'job': 'pro'}
18
{'job': 'pro'}
{}
'''
4.popitem()
随机删除并返回该键值对
序列解包
序列解包可以用于元组、列表、字典。
x,y,z=(20,30,10) print(x) print(y) print(z) (a,b,c)=(9,8,10) print(a) print(b) print(c) [a,b,c]=[10,20,30] print(a) print(b) print(c) ''' 20 30 10 9 8 10 10 20 30 '''
a={'name':'asd','age':18,'job':'pro'}
x,y,z=a
print(x)
print(y)
print(z)
q,w,e=a.items()
print(q)
print(w)
print(e)
print(q[0])
print(q[1])
b,c,d=a.values()
print(b)
print(c)
print(d)
'''
name
age
job
('name', 'asd')
('age', 18)
('job', 'pro')
name
asd
asd
18
pro
'''
集合
集合的底层是字典实现，集合所有元素都是字典的“键对象”，不能重复。
集合的创建和删除
使用{}创建集合对象，并用add()来添加元素。
a={1,3,5}
print(a)
a.add(7)
print(a)
'''
{1, 3, 5}
{1, 3, 5, 7}
'''
使用set()将列表、元组等转成集合。
a=['a','b','c','d','a']
b=set(a)
print(b)
'''
{'a', 'c', 'b', 'd'}
'''
remove()删除，clear()清空
a={1,2,3,4,5}
a.remove(2)
print(a)
'''
{1, 3, 4, 5}
'''
集合的相关操作
集合有并集、交集、差集等运算。
a={1,3,'s'}
b={'he','it','s'}
print(a|b) #并集
print(a&b) #交集
print(a-b) #差集
print(a.union(b)) #并集
print(a.intersection(b)) #交集
print(a.difference(b)) #差集
'''
{1, 'he', 3, 's', 'it'}
{'s'}
{1, 3}
{1, 'he', 3, 's', 'it'}
{'s'}
{1, 3}
'''
156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
