Python基本语法字符串、列表、字典、集合等

本文内容，主要是整理B站九天Hector的Python内容
数据技术Python基础高效入门
不可变类型包括数字、字符和元祖；
可变类型包括列表、字典和集合。

print语句

sep多对象分隔符

print("hello","world") # 默认sep = " "（空格）
print("hello","world",sep="---")

end结束符

print("hello")
print("world")
print("hello", end=",")
print("world")

字符串

字符串索引

1、对字符串进行索引时，基本格式为字符串对象[索引值]
2、Python的索引值是从0开始进行计算，也就是说，字符串中的第一个字符对应索引值为0，第二个字符对应索引值为1，以此类推。
3、利用索引，对原始对象进行有针对性的信息提取。并且字符串是支持索引的，但不能直接对索引出来的结果通过赋值的方式进行修改。
4、对于字符串而言，从最后一个字符往前，索引值还可以分别取为-1、-2、-3…以此类推

a = "Hello"
# 索引第一个字符
a[0]
# 索引最后一个字符
a[-1]

字符串切片

切片和索引是伴生的概念。所谓切片，指的是利用类似索引的方法，按照某种规则，一次性提取字符串的一个片段的字符。
切片规则：
但索引中括号内出现冒号时，则默认进行切片运算；
切片的基本规则是：字符串[切片其实位置: 切片结束位置: 每个多少取个数]；
在默认情况下，切片起始位置为0，结束位置值为字符串长度-1，第三个参数默认值为1，即全部取到；
Python切片，左闭右开（左包含又不包含）；

a = "零一二三四五六七八九十"
# 不出现冒号进行索引
a[1]
# 出现冒号时进行切片
a[1: ]
# a[1: ]等价于a[1: 11]
a[1: 11]
# 每隔两个数取一个 
a[1: 10: 2]

切片时其实索引值和末尾索引值也可用负号标注

a = "零一二三四五六七八九十"
# 第一个元素负数索引值为-11，最后一个元素索引值为-1，左闭右开
a[-11: -1]
# 若起始位置索引大于末尾索引值，则会返回空值
a[-1: -11]
# 切片第三位参数也可以取附属，表示从后往前索引
# 具体取值为-1时候，表示从后向前依次索引
a[: : -1]
# 第三位取为负时，第一位索引值必须大于第二位索引值
a[11: 1: -1]

replace方法

在Python中，函数和方法是两个不同的概念。从使用者角度而言，假设Object代表某对象，Function为函数，Method为方法，则函数的使用方法为function(object)，方法的使用方法为object.method().

# 创建对象
a = "Hallo"
# 使用replace方法替换其中的a为e
a.replace('a', 'e')

obtect.method()本身也是一个表达式，且方法内部也可传入参数；
由上述结果也可知，该表达式并不会针对原对象进行修改，而是返回了一个新的修改后的对象；
replace方法的参数解释，第一个参数为需要替换的对象，第二个参数为替换后的对象。
replace方法的可选参数作用是，但出现多个可选的替换对象时，选择替换其中前几个

find方法

用于在指定的区间内寻找确定字符串的索引值

# 在字符串Hello中寻找H字符的索引值
"Hello".find('H')  #输出0
# find过程其实就是索引的逆过程
"Hello"[0]
# 对于多次出现的字符，将返回该字符第一次出现的索引
"Hello".find('l')
# find方法可指定搜索范围，此处表示在[0, 2)索引区间内搜索'l'，若无结果，则返回-1
"Hello".find('l', 0, 2)

count方法

用于计算指定索引区域内特定字符出现的次数

# 但参数只给出字符时，会在字符串全区域进行计数
"Hello".count('l')
# 在索引区间[2, 3)中计算l出现的次数
"Hello".count('l', 2, 3)

split方法

以指定字符切分字符串，切分过程为，以该字符为界，字符前组成一个字符串，字符后组成一个字符串，并删除切分字符。

# 将Hello对象按e字符进行切分，e之前、e之后分别组成两个新的字符串
"Hello".split('e')

切分结果返回的是一个序列对象list

partition方法

partition方法和之前讲的split方法只有两点区别，其一是partition方法不会删除指定切分的元素，其二则是partition在切分包含多个指定切分字符的字符串时，只会针对第一个字符进行切分。

# 以e为切分字符，切分字符串hello
"Hello".partition('e')

strip方法

用于去除字符串首尾指定字符，当参数为空时，默认删除首位空格。

"Hello  ".strip()
"HHelloH".strip('H')

列表

列表运算符(加法和乘法)

l1 = [1, 3, 5, 7, 2]
l2 = [2, 4, "Hi"]
l1 + l2
l2 * 2

partition方法返回结果的对象类型为元组

append方法

append方法主要用于对列表对象进行追加元素操作。
在列表的末尾，追加

l = [0,1,2]
l.append(3)
l

extend方法

append方法一次只能追加一个对象，若要一次追加多个对象，则需要使用extend方法。当使用extend方法时，其参数位是需要添加的多个对象元素共共同组成的列表，即需要被追加的多个对象必须装在一个列表容器中，然后传入extend方法。

# 在l中追加两个数值型对象1、2
l = [0]
l.extend([1, 2])
l

当然，extend函数也可以只追加一个元素，但即便是一个元素，也应当将其置于一个列表容器中。
尝试追加一个列表元素，这时候需要使用列表的嵌套。

insert方法

append和extend只能在列表的末尾追加，若想要在任意位置添加元素，则需要使用insert函数。insert函数和append函数一样，一次只能添加一个元素，并且在定位位置的时候，还是需要索引值的帮助。

# insert方法第一个参数指代插入元素的索引值，第二个元素用于指代插入的元素对象
l = [0,1,2]
l.insert(1, [2, 3])
print(l)

pop方法

pop方法主要用于删除列表中的指定元素。
默认情况下（不输入任何参数的情况下），pop会删除列表中最后一个元素，并返回该元素。

# pop方法也可以通过输入索引值来删除列表中的指定元素
l = [0,1,2,3]
l.pop(0)
l

remove方法

pop方法通过索引值定位需要删除的对象，也被称为索引值删除。除此之外，实际应用当中，经常还需要依据具体的元素内容来进行删除，通过指定删除内容来执行删除，此时就需要用到remove方法。

l = list("Helalo")
print(l)
# 删除字符l，但注意，l出现了两次。此时remove函数会删除第一次出现的l
l.remove('l')
l

index方法

列表的index方法主要用于查找指定内容的索引值。

l = list("Hello")
print(l)
# 当查找对象在列表中多次出现时，将返回第一次出现的元素索引值
l.index('l')

count方法

count方法用于统计指定元素在列表中的出现次数。

l = list("Hello")
print(l)
# 统计字符l出现的次数
l.count('l')

sort方法

sort方法主要用于列表的排序，尤其是由数值型对象组成的列表排序。

l = [1, 0, 2, 3]
print(l)
# sort方法将在原对象的基础上进行修改
l.sort()

理解：在REPL环境中，每个可以执行的表达式都必将返回一个结果。返回结果要么赋值给别的变量，要么打印到屏幕上然后释放内存，若表达式中既没有赋值过程，也没有最终在屏幕中显示结果，则表明表达式的结果替换了原变量所指代的对象。

reverse方法

reverse方法用于对序列的元素排列进行翻转排序
同样，reverse方法直接在原对象上进行修改

l = [1, 0, 2, 3]
# reverse方法，对序列进行翻转
l.reverse()
l

字典

字典的创建

一般创建方法

字典由键（key）和对应值（value）成对组成的特殊元素构成，外侧则使用大括号圈定。如：

d = {'A': 1, 'B': 2, 'C': 3}

dict即表示字典，其中’A’、‘B’、'C’为字典中的键（Key），并且键值一一对应，用冒号表示对应关系；
一个字典可以包括多个键值对，每个键值对可看成是字典中的一个元素，每隔元素彼此之间用都好进行分隔；
字典中的Key智能使用不可变类型对象充当，且一个字典中的Key必须是独一无二的，而Value可用任意类型对象；

使用dict函数创建字典

列表、元组类似，字典也可以用类型同名函数dict来进行创建。由于字典数据结构比较特殊，在使用dict函数创建的过程也较为特殊，dict函数必须输入若干长度为2的元组组成的列表，才能顺利的转化为字典。
必须输入长度为二的元组组成的列表，在转化的过程中长度为2的元组中的第一个元素将变为Key，第二个元素将变为Value；
正是因为二院元组中第一个元素会对应转化为字典的Key，因此该元素对象类型必须是不可变类型对象，否则会报错。

dict([(1, 4), (2, 3)])

dict还有特殊用法，能将赋值过程转化为字典的对应关系

dict(a = 1, b = 2)

赋值过程转化为字典时，变量名称将会变成字典的Key，并且会转化为字符串；
利用该方法创建字典时，只能创建Key为字符串型的字典。

字典的索引

一般索引方法

基本索引格式为dict[key],仍然是利用中括号进行索引，只是括号内不再是索引值而是要查找的key的名称。同时，索引返回结果也不是整个Key-Value元素，而是Key对应的Value值。

d = {'A': 1, 'B': 2, 'C': 3}
# 查找key为A的元素中的Value
d['A']

同时，由于字典时可变类型对象，因此索引出来的结果既可修改。

d['A'] = 2

get方法

除了一般索引方法外，对于字典这类比较特殊的对象，通常我们还会考虑使用get方法来进行索引。和一般索引方法不同，get方法可指定当对应的key不存在时返回的结果。

# 尝试创建不同Key类型的字典
d1 = {1: 1, 'A': 2, (1,): 1}
# 当对应Key不存在时，不会返回任何结果
d1.get(3)
# 通过对第二个参数的值的输入，可指定输出当key不存在时返回的结果
d1.get(3, 'Error')

Keys/Values方法

面对字典对象，我们可以使用Keys或values方法选取字典中的keys或者values。

d = dict(A = 1, B = 2, C = 3)
print(d)
# values方法，挑选字典中的values组成新的对象
d.values()
d.keys()
# 和range类似，返回结果是原对象，若要显式显示其内容，则可使用list或者tuple函数对其进行转化
type(d.values())
# 放入list容器
dv = d.values()
list(dv)

items方法

keys和values方法都是将key或者value单独返回，而items方法则是将每个key-value键值对元素打包返回。

# 打包返回键值对，返回结果为由每个键值对构成的元组，并有这些元组所共同构成的列表，该结果仍然属于原类型
d.items()

updata方法

update函数是用于更新字典的方法，是一种非常灵活的对字典进行修改的方法。

d = dict(A = 1, B = 2, C = 3)
d1 = dict(B = 2, C = 4, D = 5)
d1.update(d)

更新原则是，有新的部分则更换或添加新的部分，其他部分保留；
更新是有方向的，d.update(d1)和d1.update(d)有本质上的区别；
更新过程会在原来对象基础上对其进行修改。

setdefault方法

setdefault方法会根据键值对原本是否存在，进行有选择的修改。
setdefault方法使用过程中，第一个参数位输入备选Key，第二个参数位置输入备选value

d = dict(A = 1, B = 2, C = 3)
# 若该备选Key在原字典中存在，则返回该Key对应的Value，第二个参数位输入的Value无任何作用
d.setdefault('A', 5)
# 若该备选key在原字典中存在，则返回该key对应的value，备选key-value将被添加至字典中
d.setdefault('D', 5)

集合

集合是一类非常特殊的对象，其既有前面提到的列表、元组等容器的功能特点，是一种无序且不可变类型容器，但只用简单形象的容器角度理解集合又会有所欠缺。一个比较合适的理解集合的角度，是将其看作字典的一种特殊形式——由字典的Keys所组成的列表。由此我们可知，集合内的元素和字典中的keys一样，其一是必须为不可变对象类型，其二是元素之间不能重复。

集合的创建

基本方法

和其他容器创建过程一样，集合也有一个一般创建方法，使用{}进行标注。

# 无序性体现
{1, 2, 'Hi', (1, 2, 3)}

Set函数创建法

# list转set
set([1, 2, 3])

这里需要注意的是，集合转化为列表或元组，本质上都是无序变量转化为有序变量，此过程需要注意输入顺序和最终输出顺序的区别。
注意：由于{}表示空字典，因此若要创建空集合，则必须借助set函数。

利用集合去重

l1 = [1, 1, 2, 3]
s1 = set(l1)
s1
ls1 = list(s1)
ls1

集合元素增加、删除方法

add方法

一种非常常见的用于在集合中添加元素的方法。

s1 = {1, 3, 2}
# 在s1集合中添加元素4
s1.add(4)
print(s1)

remove 方法

常用于删除集合中的指定元素，由于集合本身是无序对象，且元素没有key-value二元属性，因此只能通过指定的方法对元素进行删除。

s1 = {1, 3, 2}
s1.remove(2)
s1

pop方法

随机删除一个元素（实际是按照重排列后的集合显示顺序进行删除），根本原因仍然是集合的无序性。

s2 = {(1, 2), 'Hi', 1, 2}
s2.pop()
s2

集合的数学运算

交集运算

# 准备集合
s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 使用运算符&进行交集运算
s1 & s2
# 使用intersection方法进行交集运算
s1.intersection(s2)
# 使用intersection_update方法进行交集运算并覆盖原值
s1.intersection_update(s2)

并集运算

# 准备集合
s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 利用运算符|进行并集运算
s1 | s2
# 利用union方法进行并集运算
s1.union(s2)
# 使用update进行并集运算并更新原集合
s1.update(s2)

差集运算

# 准备集合
s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 使用-运算符进行差集计算
s1 - s2
# 使用difference方法求差集
s1.difference(s2)
# 使用difference_update方法求差集并更新原集合
s1.difference_update(s2)

补集运算

# 准备集合
s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 利用运算符^进行补集运算
s1 ^ s2
# 利用symmetric_difference方法进行补集运算
s1.symmetric_difference(s2)
# 利用symmetric_difference_update方法进行补集运算并更新原集合
s1.symmetric_difference_update(s2)

集合关系判断

# 准备集合
s1 = {1, 2, 3}
s2 = {2, 3}
# 使用issubset判断是否为子集
s2.issubset(s1)
# 使用issuperset判断是否为超集合
s1.issuperset(s2)
# 使用isdisjoint判断是否包含相同元素，若有相同元素，则返回false
s1.isdisjoint(s2)

循环语句

循环语句侧重于对一个容器内的每个元素依次进行某种处理，从而达到批量处理的逻辑。可以说，循环的本质就是进行批量处理，而之前介绍的“容器”的概念，则是支持批量处理最佳功能，当然，Python中之所以要创立容器，很重要的一方面原因也是希望能够借助容器的概念实现批量处理，从而提高代码表意效率。当然，这里所谓的批量处理不是真正意义上的一次性把一个容器内的所有元素“批量”的进行处理，而是将一个容器中的各元素依次执行某相同代码、再把这些结果返回并存储到某容器中，从而实现“批量”处理的效果。

可迭代对象

之前在介绍基本数据类型时，曾介绍过容器属性可从可变、有序两个方面来考察。其中：

数值型对象由于不可索引，因此不是容器；
字符串型对象可以利用数值进行索引，但不能利用索引进行修改，因此是不可变的有序变量；
列表对象可以利用数值进行索引，并且可以利用索引进行修改，因此是可变的有序变量；
元组类型对象可以利用数值进行索引，但不能利用索引进行修改，因此和字符串对象类似，是不可变的有序变量；
字典类型对象不能利用数值进行索引，只能利用key来进行索引，而Key的索引结果是可以修改的，因此字典类型对象是无序可变类型对象；
集合类型对象不能利用数值进行索引，但可以修改，因此集合类型对象和字典一样是无序可变类型对象；
冻集合是在集合的基础之上进一步要求集合本身不可变，因此冻集合是不可变的无序类型对象
在这所有的对象类型中，除了int之外，都是可迭代类型对象，都可以作为for…in…的循环对象；
根据有序、无序的不同，临时变量取值效果会有所不同；
若要利用循环对对象本身进行修改（类似上面把列表中的每个元素+1），仍然只能修改可变类型对象;
之前介绍的原容器类型对象（range、d.keys、d.values、d.items等）都是可迭代类型对象。

函数

此处内容主要来自孙兴华Python

lambda表达式

lambda语法
lambda 形参：表达式
注意：1、形参可以省略，函数的参数在lambda中也适用
2、lambda函数能接收任何数量的参数但只能返回一个表达式的值

无参数

f = lambda:520
print(f())

一个参数

f = lambda a:a
print(f(520))

默认参数

f = lambda a,b,c=5:a+b+c
print(f(2,6))

可变位置参数

f = lambda *args:args
print(f(1,2,3))

可变关键字参数

f = lambda **kwargs:kwargs
print(f(name="jack"，age=20))

带(判断)条件语句的lambda

f = lambda a,b:a if a>b else b
print(f(2,6))

filter函数

filter(函数名，可迭代对象)
作用：过渡序列中不符合条件的元素
注意：1、filter有两个参数，第一个参数可以是函数，也可以是None
2、当第一个参数是函数的时候，将第2个参数中每个元素进行计算
3、当第一个参数是None时，直接将第二个参数中为True的值筛选出来

ls = [*range(1,11)]
print(list(filter(lambda x:x%2==0,ls)))

map函数

map(函数名，可迭代对象)
作用： 将可迭代对象的每一个元素作为函数的参数进行运算加工，直到可迭代序列中每个元素都加工完毕

ls = [*range(1,11)]
print(list(filter(lambda x:x**2,ls)))

reduce函数

reduce(函数名(x,y)，可迭代对象)
作用：函数中必需有2个参数，每次函数计算的结果继续和序列的下一个元素做累积计算

import functools
ls = [1,2,3,4]
res = functools.reduce(lambda x,y:x+y,ls)

类的创建

从类的角度看待对象isinstance

列表[1, 3, 2]是列表类型的一个实例。对象和类型的关系，就是从抽象类到具体实例之间的关系。例如，大雁是一个对象，它属于鸟类，我们可以说大雁是鸟类的一个实例。

# 判断实例关系
isinstance([1, 3, 2], list)

init函数解释

1、是一种特殊函数，也称为是构造函数，多用于带参数属性的类的创建过程；
2、self是一个特殊的参数，相当于类本身的一种表示，相当于是C中的指针“this”，是init函数必须设置的第一个参数；
3、init函数是特型函数，名称不可修改；
4、两个下划线表示该函数是私有函数，只允许类的内部访问，无法通过外部访问；
5、类中定义的函数也需要传入self参数；
这些函数可以通过外部调用方法的方式进行调用。类的方法：在定义类的过程中，如果内部出现定义的其他函数，则该函数就属于类对象的方法。我们可以理解，方法其实就是绑定到对象的函数，在定义的过程中，方法是在定义类的时候同步定义的，而函数则可以随时随地单独定义，同时我们也可以理解在定义类的过程中，init函数和一般函数区别：init函数定义的参数需要在类的实例化过程中给出，而一般函数则属于类型对象实例化之后的方法。

python 中的星号[*range(5)]

python 中的星号[*]
1、在python中，函数申明的时候：
参数可以带 一个星号，表示支持不限个数的元组参数

调用的时候可以任性的 afunc(1,2,3,4,5,…,100000)

参数可以带 两个星号，表示支持不限个数的字典参数

调用的时候可以这样 bfunc(a=1,b=2,c=3,…,z=26)
2、可以对多元素对象进行展开：

In [19]: print(*range(5))
0 1 2 3 4
In [20]: a = *range(5),  # 末尾的逗号将展开的值转换为元组，如果没有逗号就会报错
In [21]: a
Out[21]: (0, 1, 2, 3, 4)
In [22]: print(*range(5),)
0 1 2 3 4
In [23]: print(*(1,2,3,4))
1 2 3 4

3、吸收多余的元素

In [3]: a,*b,c=range(5)

In [4]: a
Out[4]: 0

In [5]: b  #*b吸收了多余元素
Out[5]: [1, 2, 3]

In [6]: c
Out[6]: 4