python学习笔记02

列表list

有序集合、能够保存任意数量任意类型的 Python 对象、语法为[元素1，元素2，...，]

1、列表的创建

a = [1,2,3]
b = list(range(10))
c = list(range(1,11,2))
x = [0] * 5                    #[0 0 0 0 0]
y = [0 for i in range(5)]    #[0 0 0 0 0]
z = [i for i in range(4)]    #[0 1 2 3]
p = [i ** 2 for i in range(1, 10)]    # [1, 4, 9, 16, 25, 36, 49, 64, 81]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]    # [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]

empty = []

2、增、删、获取

list.append()          #在列表末尾添加新对象，此元素如果是一个 list，那么这个 list 将作为一个整体进行追加

list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.insert(index,obj)        #在编号 index 位置插入 obj

list.remove(obj)        #移除列表中某个值的第一个匹配项

list.pop([index = -1])        #移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。

del var1[, var2, ...]        #删除对象

浅拷贝与深拷贝

list1 = [123, 456, 789, 213]
list2 = list1        #深拷贝
list3 = list1[:]    #浅拷贝

print(list2)  # [123, 456, 789, 213]
print(list3)  # [123, 456, 789, 213]
list1.sort()  #排序
print(list2)  # [123, 213, 456, 789] 
print(list3)  # [123, 456, 789, 213]

list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2)  # [[123, 456], [789, 213]]
print(list3)  # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2)  # [[111, 456], [789, 213]]
print(list3)  # [[111, 456], [789, 213]]

3、操作符

==        +        *        in        not in

list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]

print(list1 == list2)  # False
print(list1 == list3)  # True

list4 = list1 + list2  # extend()
print(list4)  # [123, 456, 456, 123]

list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]

list3 *= 3
print(list3)  # [123, 456, 123, 456, 123, 456]

print(123 in list3)  # True
print(456 not in list3)  # False

4、其他方法

list.count(obj)        #统计某个元素在列表中出现的次数

list.index(x[, start[, end] ] )        #从列表中找出某个值第一个匹配项的索引位置

list.reverse()        #反向列表中元素

list.sort(key = None, reverse = False)         #对原列表进行排序

        reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

---

元组tuple

与列表类似可索引和切片，但不可修改，使用圆括号，元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。

t1 = (1, 2, 3, [4, 5, 6])
print(t1)  # (1, 2, 3, [4, 5, 6])

t1[3][0] = 9
print(t1)  # (1, 2, 3, [9, 5, 6])

只有count()和index()两种方法

效果与list类似

解压元组

t1 = (1, 10.31, 'python')
(a, b, c) = t1
print(a, b, c)
# 1 10.31 python

t2 = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t2
print(a, b, c, d)
# 1 10.31 OK python

通配符*   如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4]

---

字符串

使用单引号' ' 或者双引号 " "

转义字符：

转义字符	描述
\\	反斜杠符号
\'	单引号
\"	双引号
\n	换行
\t	横向制表符(TAB)
\r	回车

类似于元组不可修改，可切片和索引

str.captalize()        #将字符串的第一个字符转换为大写

str.lower()        #转化为小写

str.upper()        #转化为小写

str.swapcase()        #大变小，小变大

str.count(x , beg = 0 , end = len(str) )        #返回x在str中出现的次数，beg和end指定范围

str.endswith( x )        #检查字符串是否以指定子字符串 x结束

str.startswith( x )

str.find( x )        #检测x是否包含在字符串中

str.rfind( x )        #类似find()，从右边开始找

str.isnumeric()        #如果字符串中只包含数字字符，则返回 True，否则返回 False

str.ljust(width[ , fillchar ])        #返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。

str.rjust(width[ , fillchar ])         #返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。

str.lstrip([chars])        #截掉字符串左边的空格或指定字符。

str.rstrip([chars])        #删除字符串末尾的空格或指定字符。

str.strip([chars])        #在字符串上执行lstrip()和rstrip()。

str.partition(sub)         #找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')。

str.rpartition(sub)        #类似于partition()方法，不过是从右边开始查找

str.replace(old,new [, max ] )        #把 将字符串中的old替换成new，如果max指定，则替换不超过max次

str.split(str = " ", num)        #不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表

str.splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。

字符串格式化

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串，用str()方法处理对象
%r	格式化字符串，用rper()方法处理对象
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	根据值的大小决定使用%f或%e
%G	作用同%g，根据值的大小决定使用%f或%E

---

字典dict

字典 是无序的 键:值（key:value）对集合，键必须是互不相同的（在同一个字典之内）

dic1 = {1: 'one', 2: 'two', 3: 'three'}
print(dic1)  # {1: 'one', 2: 'two', 3: 'three'}
print(dic1[1])  # one
print(dic1[4])  # KeyError: 4

内置方法

dict.fromkeys( seq [, value ] )        用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

dict.keys()        返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。

dict.values()返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。

dict.items()以列表返回可遍历的 (键, 值) 元组数组。

dic = {'Name': 'Lsgogroup', 'Age': 7}
print(dic.items())
# dict_items([('Name', 'Lsgogroup'), ('Age', 7)])

print(tuple(dic.items()))
# (('Name', 'Lsgogroup'), ('Age', 7))

print(list(dic.items()))
# [('Name', 'Lsgogroup'), ('Age', 7)]

dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。

dic = {'Name': 'Lsgogroup', 'Age': 27}
print("Age 值为 : %s" % dic.get('Age'))  # Age 值为 : 27
print("Sex 值为 : %s" % dic.get('Sex', "NA"))  # Sex 值为 : NA
print(dic)  # {'Name': 'Lsgogroup', 'Age': 27}

dict.setdefault(key, default=None)和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

dict.pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。若key不存在，则返回 default 值。

del dict[key] 删除字典给定键 key 所对应的值。

dict.popitem()随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常。

dict.clear()用于删除字典内所有元素

dict.copy()返回一个字典的浅复制。

浅复制与直接赋值的区别

dic1 = {'user': 'lsgogroup', 'num': [1, 2, 3]}

# 引用对象
dic2 = dic1  
# 浅拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic3 = dic1.copy()  

print(id(dic1))  # 148635574728
print(id(dic2))  # 148635574728
print(id(dic3))  # 148635574344

# 修改 data 数据
dic1['user'] = 'root'
dic1['num'].remove(1)

# 输出结果
print(dic1)  # {'user': 'root', 'num': [2, 3]}
print(dic2)  # {'user': 'root', 'num': [2, 3]}
print(dic3)  # {'user': 'runoob', 'num': [2, 3]}

dict.update(dict2)把字典参数 dict2 的 key:value对 更新到字典 dict 里。

---

集合set

Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

创建集合

先创建对象再加入元素。

在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。

内置方法

set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作

set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略

set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误

set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会

set.pop() 用于随机移除一个元素

set.intersection(set1, set2) 返回两个集合的交集

set1 & set2 返回两个集合的交集

set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素

set.union(set1, set2) 返回两个集合的并集

set1 | set2 返回两个集合的并集

set.difference(set) 返回集合的差集

set1 - set2 返回集合的差集

set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值

set.symmetric_difference(set)返回集合的异或

set1 ^ set2 返回集合的异或

set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中

set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False

set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False

set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False

set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False

set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False

frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

---

序列

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作