零基础Python入门|列表，元组，字符串，序列，字典

Python入门|列表，元组，字符串，序列，字典

资源推荐：
小甲鱼：
小甲鱼课程清单
相应的课后习题

• 视频入门
• 课后习题
• 知乎大佬推荐

基础知识篇

python 学习的重点还是在于拿出你的电脑，敲敲敲代码！
当然最基础的知识也不能不知道，在此，我就用最简单的概述input了
如果大家有不明白的地方，自己搜索一下搞懂，
写下来的都很基础且简单，比较难的会有详细解答
so基础你看不懂的话
后期很崩溃的,必须搞懂！冲冲冲~
加油！

1.需要键入一些特殊符号，可以使用转义字符 \
eg: 'I \'love\'you'
显示为： “I 'love’you”
2.BIF：
Built-in-Function 内置函数，可以直接调用
3.
isdigit()
检测字符串是否只由数字组成
如果字符串只包含数字则返回 True 否则返回 False

• 列表
• 元组
• 字符串
• 序列
• 字典

列表

浅拷贝：
只是拷贝了外层对象，如果包含嵌套对象的话，则拷贝的只是其引用

• y = x.copy()
• y = x[:]
• y = copy.copy(x)

深拷贝：
copy模块：
import copy
两个函数：
copy浅拷贝
deepcopy深拷贝：将原对象拷贝的同时，也将对象中所有引用的子对象进行了拷贝
y = copy.deepcopy(x)

列表推导式

oh = [1,2,3,4,5]
oh = [i*2 for i in oh]

oh变为[2, 4, 6, 8, 10]
[expression for target in iterable]
[表达式 for 变量 in 可迭代对象]

code = [ord© for c in ‘love’]

ord©将字符c转换成对应的Unicode编码

嵌套列表的创建：
r = [[0]*3]*3
r错误，创建的嵌套列表动一发而变全军
s = [[0] * 3 for i in range(3)]
s对咯
[expression for target in iterable if condition]
eg:

words = ['hhaha','fish','brilliant','fancl','flower']
f = [c for c in words if c[0] == 'f']

f
[‘fish’, ‘fancl’, ‘flower’]

元组

rhyme = (1,2,3,4,5,"上山打老虎")
%元组用圆括号或者省略掉其括号
rhyme = 1,2,3,4,5,"上山打老虎"
rhyme
(1, 2, 3, 4, 5, '上山打老虎')
rhyme[0]%元组不可修改
1
rhyme[-1]
'上山打老虎'

只能 查：

count
index
+拼接
*重复

元组的生成: 打包
元组的调用：解包

字符串

以下都是对字符串而言：

大小写字母更换：

• capitalize大写第一个字母
• casefold全部变小写
• title第一个字母都大写
• swapcase大小写反转
• upper全部大写
• lower全部小写

x = 'I love U'
x.title()
'I Love U'
x.casefold()
'i love u'
x.capitalize()
'I love u'
x.swapcase()
'i LOVE u'
x.upper()
'I LOVE U'
x.lower()
'i love u'

左中右对齐：

center（width，fillchar=’’) 置中
ljust(width,fillchar = ‘’) 左对齐
rjust(width,fillchar=’’) 右对齐
zfill(width) 填补0

width 指定宽度
fillchar = ‘’ 如果无，就是空格填充，但也可改成自己喜欢的玩意

x.rjust(15,'淦')
'淦淦淦淦淦淦有内鬼！停止交易！'

x = '有内鬼！停止交易！'
x.center(15)
'   有内鬼！停止交易！   '
x.ljust(15)
'有内鬼！停止交易！      '
x.rjust(15)
'      有内鬼！停止交易！'
x.zfill(15)
'000000有内鬼！停止交易！'

查找

• count（sub[ , start[, end] ] )
  sub在字符串中出现的次数

• find ( sub[, start[, end]])
  从左向右找sub，返回找到的第一个的索引值

• rfind( sub[, start[, end]])
  从右向左找sub

• index( sub[, start[, end]])

• rindex( sub[, start[, end]])

替换

expandtabs([tabsize = 8]）
将tab替换成空格
？没有用

replace(old, new, count = -1)
count 替换的次数，默认为-1，替换全部

translate（table)

str.maketrans( a, b,c)
忽略c

判断

返回bool类型值，true / false

• startswith(prefix,[,strat[,end]])判断所给字符串是否出现在最开始

• endswith(prefix,[,strat[,end]])是否出现在最末尾
  注：[]指的是可选参数，在这里，可以为：
  startswith（“ok”,2,6)表示从下标2开始到5结束，ok是不是最开始出现的字符串，是为True,不是为False

• istitle()是否每个单词大写开头

• isupper()是否每个字母都大写

• isalpha()是否都是字母

• isspace是否为一个空白字符串

• isprintable是否可打印
  例如：\n转义字符不可以打印出来

• isdecimal()

• isdigit()

• isnumeric()
  上面三个都是检测是否为数字

• isidentifier()
  是否为合法的python标识符（不可以以数字开头，可用英文和下划线，数字（不在开头）

截取

• lstrip()左侧空格被截掉
• rstrip()右侧空白不要
• strip()左右不留白
  注意：如果在（）内加入参数，可以表示为在哪边不要哪个，是字符一个个对应的，单个字符
  用下面的方法吧：
  指定的字符串
• removeprefix()删除前缀
• removesuffix()删除后缀

拆分&拼接

拆分：

• partition(sep) 从左到右

• rpartition(sep) 从右到左
  将字符串以参数指定的分隔符进行切割，并将切割后的结果返回一个三元组（分隔符以前，分隔符，分隔符之后的内容）

• split(sep = None,maxsplit = -1)

• rsplit(sep = None,maxsplit = -1)
  maxsplit：切几刀
  按照分隔符，划分

• splitlines()
  按照行进行切割，并把结果以列表的形式返回
  在括号内变默认false为true的话（记住程序里要大写第一个字母）的话，把转义字符（如：Linux里的\n,window的\r\n,mac的\r）打印出来

拼接：

• join(iterable)
  使用分隔符"sth"把字符串拼接起来

 "&".join(("把你的","心","我的心","串一串"))

‘把你的&心&我的心&串一串’

易错提醒:在这里join()只能有一个参数，因此你可以看到此处是把(“把你的”,“心”,“我的心”,“串一串”)这一个元组（也可以用列表）放入括号成为一个参数，不要直接上来几个字符串就扔括号里了，会报错哒！

" & ".join(["把你的","心","我的心","再串一串"])
             
'把你的 & 心 & 我的心 & 再串一串'

join拼接要比直接用+来得快

格式化字符串：

• format()
  {} 里面写数字，表示参数的位置
  如果里面写入关键字，就是关键字参数

'我和彭于晏订婚于{date}'.format(date = "2028.5.20")
             
'我和彭于晏订婚于2028.5.20'

date = '2028.5.20'
             
'我和彭于晏订婚于{}'.format(date)
             
'我和彭于晏订婚于2028.5.20'

通过填充选项来填充指定的字符：

"十年寒窗{:<15}难凉热血{:*>15}".format("?","!")
             
'十年寒窗?              难凉热血**************!'

符号选项：

{：+}显示正号
{：-}可以不加也能显示，负号
适用于整数：
二进制…输出
适用于浮点数：

精度：
（不用在整数上）

"{:.2f}".format(3.1415926)
             
'3.14'
"{:.2g}".format(3.1415926)
             
'3.1'

千位分隔符{：，}或者{：_}

align 对齐方式

f-字符串
普通字符串之前加上一个前缀F（f)
是format语法的语法糖

序列

列表，元组，字符串，统称为序列

序列：

• 可变序列：列表[]
• 不可变序列：元组（）和字符串""

能够作用于序列的：

• +序列拼接
• *序列重复（拷贝）

python中每个对象都有三个属性：
1. 唯一标志：对象创建就有，不可被修改: id()
2. 类型
3. 值

同一性运算符：

• is
• is not

包含问题：

• in 判断某个元素是否包含在序列中

• not in

• del删除
  （也可以用切片来实现）
  不过del可以使用步长，切片用不了
  eg:

x = [1,2,3,4,5]
             
del x[::2]
             
x
             
[2, 4]

与序列相关的函数：

列表，元组，字符串相互转换：

• list()

• tuple()

• str()
  将可迭代对象转换为list列表，tuple元组，str字符串

• min()

• max()
  对可迭代对象进行比较
  如果是对字母，按照字母编码值来比较大小，其中大写字母编码值在小写字母之前，也就是说，max(‘f’,‘F’) =‘f’

• len()

• sum()计算求和

s = [1,2,3,56,73,2]
             
sum(s)
             
137
sum(s,start = 100)
             
237

start = 表示从某个值开始加

• sorted()返回一个全新的列表，原来的列表不受影响
  区分：假如调用的是列表的分类s.sort(),那么这个s列表就会改变为排好序后的
  且sorted可以接受任何可迭代对象作为参数

sorted(s)
             
[1, 2, 2, 3, 56, 73]
s
             
[1, 2, 3, 56, 73, 2]
s.sort()
             
s
             
[1, 2, 2, 3, 56, 73]
sorted(s,reverse = True)
             
[73, 56, 3, 2, 2, 1]

reverse默认为False，设置为True则翻转排序
sorted(t,key = len)
key参数指定的是一个干预排序算法的函数

• reversed()反向迭代器
  eg:list(reversed(s))

• all()是否所有值为真

• any()是否存在某个值为真

• enumerate（）

seasons = ['spring','summer','fall','winter']
             
list(enumerate(seasons))
             
[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]
list(enumerate(seasons,10))
             
[(10, 'spring'), (11, 'summer'), (12, 'fall'), (13, 'winter')]

- zip()

x = [1,2,3]
             
y = [4,5,6]
             
zip1 = zip(x,y)
list(zip1)
             
[(1, 4), (2, 5), (3, 6)]

长度不一样时，只取最短的那个
itertools模块里面有个zip_longest()函数，可以实现取最大的长度
eg:
z = [7,8]
list(itertools.zip_longest(x,y,z))
[(1, 4, 7), (2, 5, 8), (3, 6, None)]

• map()
  list(map(ord,‘fishc’))
  [102, 105, 115, 104, 99]

ord求出字符的Unicode编码

map(计算函数，可迭代对象）
如果可迭代对象长度不一致，都是取最短的

• filter()
  根据提供的函数对指定的可迭代对象的每个元素进行运算，将运算结果为真的元素以迭代器的形式返回

list(filter(str.islower,'AbCdEGf'))
['b', 'd', 'f']

可迭代对象可以进行重复使用
迭代器是一次性的

iter()
将可迭代对象变为迭代器

next(）逐个将迭代器里的元素提取出来

字典

字典：python中唯一实现映射关系的内置类型
映射关系：
提供键，得到值
不可以分片

创建字典

1. 直接使用{：，：，：}
2. dict(键=’值‘)注意：键上不要加引号
3. dict([(),(),()])

a = {"彭于晏":"第一男神","韩东君":"第二","还有谁":"第三？"}
b = dict(彭于晏="第一",韩东君 = "第二",还有谁 = "第三？")
c = dict([("1","彭于晏"),("2","韩东君"),("3","which one?")])
d = dict({"彭于晏":"第一男神","韩东君":"第二","还有谁":"第三？"})
e = dict({"彭于晏":"第一男神","韩东君":"第二"},还有谁="第三？")
f = dict(zip(['1','2','3,'],['pyy','hhh','which one?']))

增

• fromkeys(iterable[,values])

字典中键不可以重复

删

• pop()
• popitem()删除最后一个加入字典的键值对
• del 关键字 删除字典（直接没），删除字典中的某一个键值对
• clear清空字典中的内容，变为空字典

改

• update([other])

查

get(key[,default])
查找key所对应的值，没有的话返回default

setdefault()
当字典中没有的时候，将之加入进去

视图对象：

• items() 键值对
• keys()
• values()
  字典改变，其视图对象跟着改变

浅拷贝
copy()

嵌套

字典推导式
d = dict(a = ‘1’,b = ‘2’,c = ‘3’)
b = {v:k for k,v in d.items()}