天池龙珠第二天

天池

python笔记

is,is not和 == ，！=。

前者对比的是两个变量的内存地址。

后者对比的是两个变量的值。

decimal包：可以实现取小数点后面就几位。decimal.getcontext().prec = 4

bool可以对数组和元组、列表进行判断。

isinstacne（）：会认为子类是一种父类类型，考虑继承关系。可用于判断两个类型是否相同。

type（）：不会，不考虑。

类型转化：int (x)；这种，类型（变量）的格式。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WpWJa1gY-1627399974330)(E:\Typora\Typora\image-20210725214731947.png)]

print里面有多个输出参数时，可以设定step作为区分。

while else相当于java中的for else。

for in 可以遍历元组。

for in else：执行完for in里面的东西之后执行else。若没有执行完则不执行else

range([start,] stop[,step=1]);

enumerate(sequence,[start=0])函数

其中，sequence为一个支持迭代的对象。，start为下标起始位置。返回enumerate（枚举）对象。

seasons=['spring','summer','Fall','Winter]
lst=list(enumerte(seasons))
print(lst)

输出的集合不带重复的元素。

第二天

列表、元组、字符串、字典、集合、序列

列表：

有序集合、没有固定大小、可以存储任意数量、任意类型的python对象

​ 语法：x=[’’,’’,…]

由于list里面可以是任何对象，所以列表保存是指针。

形式：

1、x=[’’,’’,…]

2、利用list，例如：x=list(range(1,10,2))

3、利用推导式，例如：x=[i for if in range(10)]

4、还有其他的形式

list.append(’ '),向列表末尾添加新的对象，一次只能添加一个元素，所添加的元素在list中保持原来的数据类型，可以 追加去一个列表（套娃）

len(x),对象x的长度。

list.extend(),向当前列表补充另一个列表的元素。

list.insert(index,obj),在index号的位置插入obj。

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

​ list.pop([index-1])移除列表中的一个元素。序号

​ del list[0:3],将list里面0-2号的元素删除。

返回列表值：x[start:stop:step],输出从start到stop间隔step个。包括start，不包括stop。

下面的知识点在程序上能跑通，但是和查到的知识点不太一样。

浅拷贝：list3=list1[:],将 地址和元素全部拷贝。

深拷贝：list2=list1,拷贝list1的地址。

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

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

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

list.sort(key==,reverse==)key为排序的参数reverse==true升序，false将序

x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)

元组

定义：(item1,item2,…)

元组用小括号，也可以不用，列表用方括号。元组一旦创建后，不能进行修改，类似字符串。

不能修改，但是可以借助其他方法重组。

更新：

week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week)  # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

删除：更改元组中可供更改的元素实现删除。

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])

元组相关操作符：

*是重复操作符，重复操作符，重复操作符。

t1=(123,456)
t5=t3*3
print(t5)
#(123,456,123,456,123,456)

count、index

count:返回元组中该元素出现了几次。

index：返回该元素在元组中的索引。

t = (1, 10.31, 'python')
print(t.count('python'))  # 1
print(t.index(10.31))  # 1

解压元组：

即用其他变量来表示元组中的元素。元组里面有几个元素，就定义几个变量。

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

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

t = 1, 2, 3, 4, 5
a, b, *rest（或者可以吧rest换成_）, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4]

字符串

定义：引号之间的字符集合。

print(5+8)#13
print('5'+'8')58

很明显，下面的那个式子里面发挥的作用是拼接。

转义字符：也就是加个\后面的才是能被计算机识别的

\\反斜杠符号
\'单引号
\"双引号
\n换行
\t 横向制表符，就是个大空格
\r 回车

拼接类似元组。

s = 'Python'
print(s)  # Python
print(s[2:4])  # th
print(s[-5:-2])  # yth
print(s[2])  # t
print(s[-1])  # n

capitalize()将字符串的第一个字符转换为大写

lower（）转换字符串中所有大写字符为小写

upper()转换字符串中所有小写字符为大写

swapcase()将字符中的，大写变小写，小写变大写。

下面三个方法，可以指定开始和结尾。

count(str,beg=0,end=len(string))返回str在string中出现的次数。

endswith(suffix,beg=0,end=len(string))检查字符串是否以指定字符串suffix结尾。

startwithe（suffix，beg=0,end=len(string))检查字符串是否以指定字符串suffix开头

isnumeric（），检查字符串中是否 只包含数字。返回True，False

ljust(width,‘a’):返回字符串的左对齐，width：个数，a：用来填充的变量。

rjust（width，’a’)作用同上。

切割：

lstrip（[chars]）:截掉字符串左边的空格或指定字符

rstrip（[chars]）:截掉字符串右边的空格或指定字符

strip([chars]):

strip().replace(old,new,sum);

strip().partition(sub),

strip().split(str="",num) str:字符串以str作为分割，num，分割为多少个子字符串。如何没有这俩参数，以空格为分割。以分割后的列表的形式返回。

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

str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']
print(str6.splitlines(True))  # ['I \n', ' Love \n', ' LsgoGroup']

maketrans(intab,outtba),创建字符映射的转换表。第一个参数时字符串，表示要转换的字符，第二个参数时字符串转换的目标。

translate(table,deletechars=" ")根据参数table给出的表，转换字符。

一般来将第一个是给第二个服务。

str7 = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab, outtab)
print(str7.translate(trantab))  # th3s 3s str3ng 2x1mpl2....w4w!!!

format：格式化函数，format前后的位置要对应。

例子：

str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数
print(str8)  # I Love Lsgogroup

str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数
print(str8)  # I Love Lsgogroup

str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前
print(str8)  # I Love Lsgogroup

str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
print(str8)  # 27.66GB

字典

以“关键字”为索引，关键字可以是任意不可变类型，通常是字符串或数值。

序列是已连续的整数位索引。

字典是Python唯一的一个映射类型。字符串、元组、列表属于序列类型。

判断数据类型x是不是可变类型

麻烦方法：用id（x）函数，对x进行某种操作，比较前后的id，如果不一样，则不可变，如果一样则可变。

简单方法：用hash（x），只要不报错，就说明x可被哈希。则不可变。

i = 1
print(id(i))  # 140732167000896
i = i + 2
print(id(i))  # 140732167000960

l = [1, 2]
print(id(l))  # 4300825160
l.append('Python')
print(id(l))  # 4300825160

定义：键值对的集合。

字典的两种创建方式：

brand = ['李宁', '耐克', '阿迪达斯']
slogan = ['一切皆有可能', 'Just do it', 'Impossible is nothing']
print('耐克的口号是:', slogan[brand.index('耐克')])  
# 耐克的口号是: Just do it

dic = {'李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing'}
print('耐克的口号是:', dic['耐克'])  
# 耐克的口号是: Just do it

第二种，由大括号、分号、冒号构成

第一种：两个方框对应组成。

复制：dic1=dict([(‘key’,value)…])

内置方法：

dict.fromkeys(seq，value)。

例子：

seq = ('name', 'age', 'sex')
dic1 = dict.fromkeys(seq)
print(dic1)
# {'name': None, 'age': None, 'sex': None}

dic2 = dict.fromkeys(seq, 10)
print(dic2)
# {'name': 10, 'age': 10, 'sex': 10}

dic3 = dict.fromkeys(seq, ('小马', '8', '男'))
print(dic3)
# {'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}

dict.keys()返回一个可迭代对象。也就是里面的例子。还可以用list（）来转化列表

dic = {'Name': 'lsgogroup', 'Age': 7}
print(dic.keys())  # dict_keys(['Name', 'Age'])
lst = list(dic.keys())  # 转换为列表
print(lst)  # ['Name', 'Age']

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)返回指定键的值，如果没有这个值，则返回default

dict.setdefault(key,default=None),如果键不存在字典中，则添进去。值为default。

key in dict。返回True 或者False

dict.pop(key,“default”) #删除字典中key所对应的值，并将该值返回。若key不存在，则返回default值，这玩意由自己给定。

del dict[key]删除字典key所对应值

dict.popitem():随机返回并删除字典中的一对键和值。检测字典是否为空的方法。

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

赋值与复制

不同，copy后地址不同。

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

# 引用对象
dic2 = dic1  
后者
dic3 = dic1.copy()  


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更新dict，有则改之，无则补之。

集合（set）

和dict类似，也是一组key的集合，但不能存储value，且key不重复。

创建方法：大括号。

set={‘a’,‘b’,‘c’}

添加方法：set.add()

set(value)工厂函数，把列表或元组换成集合

例子：b=set((列表)) 。b=se([元组])

len()集合的大小。

set.add(elmnt)给集合中添加元素。

set.update(set)可以把集合或元素添加到集合中。

set.remove(item)移除，dddd

set.discard(value)移除指定的集合元素，不会报错，上面的会。

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)移除异或的，更新到当前集合。

a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}

c = a.symmetric_difference(b)
print(c)  # {'m', 'r', 'l', 'b', 'z', 'd'}
print(a ^ b)  # {'m', 'r', 'l', 'b', 'z', 'd'}

这种情况下的异或，是两个集合都有的元素。

set.issubset(set)判断集合是不是被其他集合包含。返回True或False

set1<=set2同上

set.issuperset(set)判断结合是不是包含其他集合。

set1>=set2同上。

set.isdisjoint(set)判断集合是不是不想交

集合转换

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>

不可变集合

不能增加或删除元素，可以进行其他不带update的方法。

frozenset(range(10))

序列

list(sub)把一个可迭代对象转换为列表

tuple(sub)同上变元组

• sorted(iterable, key=None, reverse=False)
  

  对所有可迭代的对象进行排序操作。

  • iterable – 可迭代对象。
  • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
  • 返回重新排序的列表

enumerate(sequence, [start=0])`

将一个可遍历对象，索引化。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a = list(enumerate(seasons))
print(a)  
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

• zip(iter1 [,iter2 [...]])
  

  • 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
  • 我们可以使用 list() 转换来输出列表。
  • 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

zip(iter1 [,iter2 [...]])
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]

zipped = zip(a, b)
print(zipped)  # <zip object at 0x000000C5D89EDD88>
print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
zipped = zip(a, c)
print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]

a1, a2 = zip(*zip(a, b))
print(list(a1))  # [1, 2, 3]
print(list(a2))  # [4, 5, 6]