python重要基础整理

字符串

字符串的索引和循环迭代

s="string"
print(s[0]) # 结果 s
print(s[0,1])# 结果st # 取0，1这两个索引
print(s[0:3])# 结果 str # 取0到2 的所有字符
print(s[0:5:2])# 结果 srn # 取0到5 步长为2的字符
for i in s:print(i,end="") # 输出结果 string

字符串的函数

find，index函数 包括find lfind rfind rindex lindex 基本语法 find为例：str.find(“要找的字符”,start,end)

# 字符内置函数
# start和end如果不写默认从头开始找 写了则从start开始找到end结束 找到了则返回第一个字符的索引值 找不则返回-1
s="anbcdingcsaggaadf"
print(s.find("c")) # 结果3   # 返回的是第一个c的索引值
print(s.find("c",5,10)# 结果 8 # 是从第五号位开始找到第10号位结束 
print(s.find("c",5)# 结果 8 # 表示从五号位开始找 到最后 
#lfind 和 rfind 就是从左开始和从右开始的区别
#index lindex rindex和find的用法一样区别在于 find找不到返回-1 index找不到会报错

replace函数 基本语法 str.replace(“旧字符”,“新字符”,个数)

s="anbcd ingc saggaa df"
New_s=s.replace('a',"你好")
print(New_s) # 结果 你好nbcdingcs你好gg你好你好df  # 全部的a都被替换成了你好
# 注意返回值是替换后的结果 这并没有对原来的字符串进行任何修改 （字符串是不能被修改的New_s1=s.replace('a',"你好",2)
print(New_s1)# 结果 你好nbcdingcs你好ggaadf 只有两个a 被替换了New_s2=s.replace(' ',"") # 这是常用的去掉字符串内部空格的方法
print(New_s2)# 结果 anbcdingcsaggaadf

字符大小写函数 capitalize, title, upper, lower casefold ，swapcase 基本语法capitalize为例 ： str.capitalize()

# capitalize() 字符串开头字母大写
s="adf_afdfa dfaf你好afd,adfdf/werfs"
print(s.capitalize()) # Adf_afdfa dfaf你好afd,adfdf/werfs 只是字符串首字母大写#title()每一个被特殊字符隔开的字母都大写 特殊字符有 空格 # , / _ 中文 
print(s.title()) #Adf_Afdfa Dfaf你好Afd,Adfdf/Werfs# lower和casefold函数 全部变为小写
s="ADFADfdfasdfa"
print(s.casefold())
print(s.lower()) 
#二者输出结果均为 adfadfdfasdfa# uper() 全变为大写
print(s.upper()) #结果 ADFADFDFASDFA#swapcase() 大小写互换
print(s.swapcase()) #结果 adfadFDFASDFA

split 和 join函数 分割和链接字符串 基本语法split：str. split(“分割字符”)，“连接字符”.join(list)

# split函数
s="naa dfd adf adfa df"
# 不指定分割字符 默认以空格作文分割
print(s.split())  # 结果['naa', 'dfd', 'adf', 'adfa', 'df']
# 指定以a作为分割符
print(s.split("a")) # 结果 ['n', '', ' dfd ', 'df ', 'df', ' df']# join函数
lst=['naa', 'dfd', 'adf', 'adfa', 'df']
print("_".join(lst)) # 结果 naa_dfd_adf_adfa_df 
# 将列表里面的每一个元素用_连接起来了
# join在运用的时候需要注意 列表里面的每一个元素都必须为字符串
lst=['naa', 'dfd', 123, 'adfa', 'df'] # 这种列表里面有一个不是字符串的元素 会报错
print("_".join(lst)) # 结果 报错

endswith，startswith 函数 判断以什么开头或者以尾没结尾 基本语法：str.endswith(“字符”) 返回值为True 或者False

s="naa dfd adf adfa df"
#判断是否以f结尾
print(s.endswith("f")) # 结果 True
#判断是否以f开头
print(s.startswith("f")) # 结构为False

count center strip函数

# count函数 计算字符串中某个字符出现的次数 语法： str.count("字符",start,end)
s="naa dfd adf adfa df"
print(s.count("f"))# 结果 4  # 是对整个字符串进行计数
print(s.count("f",6,15)) #结果 2 # 是对索引为6到15的字符串进行计数
print(s.count("f",6))#结果 3 # 是从索引为6 开始计数#center函数 增加某一字符串的长度 基本语法 str.center(增加到的长度,"填充的字符")
s="123"
print(s.center(10,"s"))#结果 sss123ssss  # 把原有字符置于整个字符串的中小 其他位置用填充字符填充到10#strip函数 包括lstrip rstrip 去掉两端的某一字符 基本语法str.strip(“想要去掉的字符”)
#strip是去掉两端 lstrip是去掉左边 rstrip是去掉右边
s="123 "
print(s.strip()) # 结果为 123 # strip里面什么都不加默认是去掉两端的空格
s="das123asd"
print(s.strip("d")) #结果 as123as # 指定去掉两端的“d”字符 

decode encode bytes函数

#encode是对unicode字符串进行编码 变为二进制数据类型 基本语法:str.encode("utf-8") #utf-8是常用的编码形式  也可以选用gbk
s="das123asd你好"
print(s.encode("utf-8"))#结果 b'das123asd\xe4\xbd\xa0\xe5\xa5\xbd'
#decode是对二进制码进行解码 进制的编码变回unicode的编码
new_s=s.encode("utf-8")
#这里 new_s 是用utf-8来编码的 下面解码就必须用uft-8 
print(new_s.decode("utf-8") # 结果 das123asd你好# bytes函数 也是将数据变为二进制代码 基本语法 bytes(str,encoding="utf-8") 同样可以选用gbk
new_s1=bytes(s,encoding="utf-8")
print(new_s1)#结果 b'das123asd\xe4\xbd\xa0\xe5\xa5\xbd'

字符串的小训练

# 1 对把下面列表用_链接起来
a=[1,"老男孩","武sir"]
def func(a):  for index,value in enumerate(a): # a 为列表 进入函数解包后装包变为了元组 元组的元素不可更改a[index]=str(value)c="_".join(a) # join 要求列表中的每一个元素都为字符串类型return c
a=[1,"老男孩","武sir"]# 现在1为int类型
func(a) # '1_老男孩_武sir'#2 打印出下列图形
'''*    ***   *****  ******* 
*********'''
for i in range(1,10):s="*"*(2*i-1)#print(s)print(s.center(9," "))

列表

列表切片和列表循环

列表切片和字符串切片几乎一样这里不再赘述

列表for循环

#列表简单for循环
lst=['naa', 'dfd', 'adf', 'adfa', 'df']
for i in lst:print(i,end=" ")# 结果 naa dfd adf adfa df #列表for循环和else嵌套
for i in lst:print(i,end=" ")# 结果 
else:print("end")
#输出结果  naa dfd adf adfa df  end 
# 当for循环结束的时候执行else下的命令
count=0
for i in lst:print(i,end=" ")# 结果 count+=1if count==2:break
else:print("end")
# 输出结果 naa dfd  
#循环第一次的时候 打印了 列表的第一个元素 count+1 变成1 
#循环第二次的时候 打印了 列表的第二个元素 count+1 变成2 这个时候满足if条件执行break
#break执行之后终止for循环 else下的命令也不再执行 

列表相关的函数

列表的增加 append ，extend，insert

# append 基本用法 lst.append("要增加的元素")  append是在列表末尾追加元素 并且是对原列表直接修改
lst=['naa', 'dfd', 'adf', 'adfa', 'df']
lst.append("你好")
print(lst) #结果 ['naa', 'dfd', 'adf', 'adfa', 'df', '你好']# extend 函数基本语法和append差不多 但是又一点区别
lst=['naa', 'dfd', 'adf', 'adfa', 'df']
lst.extend("你好")
print(lst) #结果 ['naa', 'dfd', 'adf', 'adfa', 'df', '你', '好'] #把“你好”都分开装进了列表里面
# 如果不想分开装需要用[] 把元素要增加的元素括起来
lst=['naa','dfd', 'adf', 'adfa', 'df']
lst.extend(["你好"])
print(lst)# 输出结果 ['naa', 'dfd', 'adf', 'adfa', 'df', '你好']#insert 函数 是指定在某个位置插入某个元素 基本语法 str.insert(索引位置,"要插入的字符")
lst=['naa', 'dfd', 'adf', 'adfa', 'df']
lst.insert(2,"你好")
print(lst) #输出结果 ['naa', 'dfd', '你好', 'adf', 'adfa', 'df'] # 在二号位插入了"你好"

列表的删除 del ,remove,pop, clear

# del函数 可以指定删除那个号位元素，可以删除单个，也可以切片删除 基本语法 del list[start:end:step] 是对原列表直接修改 
lst=['naa', 'dfd', '你好', 'adf', 'adfa', 'df']
del lst[1] # 指定删除1号为元素
print(lst) # 结果 ['naa', 'adf', 'adfa', 'df']lst=['naa', 'dfd', '你好', 'adf', 'adfa', 'df']
del lst[1:4] # 指定删除1号位到4号位的元素
print(lst) # 结果 ['naa', 'adfa', 'df'] lst=['naa', 'dfd', '你好', 'adf', 'adfa', 'df']
del lst[0:6:2] #指定每间隔一个删除一个 也可以写成 del lst[::2]
print(lst)# ['dfd', 'adf', 'df']# remove函数 指定移除某一个元素 基本语法 lst.remove("要删除的元素") 如果有多个相同的元素 只删除的第一个 没有返回值
lst=['naa', 'dfd', '你好', 'adf', 'adfa', 'df',"你好"]
lst.remove("你好") 
print(lst)#  ['naa', 'dfd', 'adf', 'adfa', 'df', '你好'] 删除了第一你好# pop函数 是删除列表最末尾的元素，有返回值返回值为删除的元素, 直接对列表进行修改，基本语法list.pop()
lst=['naa', 'dfd', '你好', 'adf', 'adfa', 'df',"你好"]
a=lst.pop()
print(a)# 你好
print(lst)# ['naa', 'dfd', '你好', 'adf', 'adfa', 'df'] 
#clear函数是直接清空所有列表

列表的其他函数 sort，zip，enumerate

# sort函数 是对列表进行排序 直接对原列表进行修改 用法 lst.sort()
lst=[1,34,56,34,57,3,55]
lst.sort()
print(lst) 结果 [1, 3, 34, 34, 55, 56, 57]# zip函数 可同时对多个列表进行循环迭代 主要用于for循环 基本是 for i1,i2,...,iN in zip(list1,list2,...,listN)
lst1=[1,34,56,34,57,3,55]
lst2=['naa', 'dfd', '你好', 'adf', 'adfa', 'df']
for i,j in zip(lst1,lst2):print(i,j)
'''
输出结果：
1 naa
34 dfd
56 你好
34 adf
57 adfa
3 df
'''
#由上面的输出结果可以看出 循环迭代终止是以最短的那个列表计算的，最短的列表中没有元素了可以迭代了 那么for循环旧终止了#枚举 enumerate  也是用于for循环 for i,j in enumerate(list) 返回的i对应的是列表的索引，j是列表的元素
lst=['naa', 'dfd', '你好', 'adf', 'adfa', 'df']
for i,j in enumerate(lst):print(i,j)
'''
输出结果
0 naa
1 dfd
2 你好
3 adf
4 adfa
5 df
''' 

字典

字典for循环

dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦老板'}
#直接循环 取字典的键
for i in dic:print(i) # 结果 k1 k2 s1 
#函数keys 取字典的键 
for i in dic.keys():print(i,end=" ")  # 结果 k1 k2 s1  和直接循环没区别#函数values取字典值
for i in dic.values():print(i,end=" ") # alex wusir ⾦老板 #items 取字典的键值对
for i,j in dic.items():print(i,j)
'''
输出结果
k1 alex
k2 wusir
s1 ⾦老板
'''

字典的增删改

字典的增加

# 基本语法 dict["新键"]="新值"
dic = {'k1': 'alex', 'k2': 'wusir'}
dic["k3"]="你好"
print(dic) # {'k1': 'alex', 'k2': 'wusir', 'k3': '你好'}

字典的修改

# 基本语法 dict["键"]="新值"
dic = {'k1': 'alex', 'k2': 'wusir'}
dic["k1"]="你好"
print(dic) # {'k1': '你好', 'k2': 'wusir'}

字典的删除

# del 函数 用法 del dict["键"]
dic = {'k1': 'alex', 'k2': 'wusir'}
del dic["k1"]
print(dic) # {'k2': 'wusir'}

字典的其他知识

# 将两个元素的元组变成字典
tup1=("name","jack")
tup2=("age","22")
dic=dict([tup1,tup2])
print(dic) # {'name': 'jack', 'age': '22'}# get函数 基本用法 dict.get("键","默认值") 如果 “键” 在字典中则返回键对应的值 如果键不在,则返回默认值
dic={'name': 'jack', 'age': '22'}
print(dic.get("name","没有找到")) # 结果jack
print(dic.get("color","没有找到")) #结果 没有找到  # 这个时候dic里面没有对应的键 所以返回默认值 #fromkeys函数 将两个的列表变为字典，第一个列表的每个元素作为键，第二个列表整体作为每个键的值
dic=dict.fromkeys(["jay","jj","aa"],["zhou","zhang"])
print(dic)# {'jay': ['zhou', 'zhang'], 'jj': ['zhou', 'zhang'], 'aa': ['zhou', 'zhang']}

集合

判断子集，求并集 ，差集，交集 和对称差集

# < 或者 issubset 判断是否为子集 
set1={1,23,4}
set2={2,3,4,5,6,23,1}
print(set1<set2) # 结果 True
print(set1.issubset(set2))# 结果 True
# issuperset是用于判断是否为超子集（超子集也叫真子集） 用法和issubset一样# 并集 | 或者 union 函数
set1={1,23}
set2={2,3}
print(set1.union(set2))
print(set1|set2) 
# 输出结果均为 {1, 2, 3, 23}# 差集  - 或者  difference
set1={1,23,2}
set2={2,3}
print(set1.difference(set2))
print(set1-set2)
# 输出结果均为 {1, 23}#交集 & 或者 intersection
set1={1,23,2}
set2={2,3}
print(set1.intersection(set2))
print(set1&set2)
# 输出结果均为 {2}# 对此差集 ^  解释一下：对称差集是把两各集合并起来之后去掉两个集合的交集 即去掉两个集合共有元素后，剩下的元素再合并起来
set1={1,23,2}
set2={2,3}
print(set1^set2)# {1, 3, 23}

集合的增删

# 集合的增加 update 和 add 函数
set1={1,23,2}
set1.add("你好")
print(set1)# {1, 2, '你好', 23} # 这里注意随便增加在哪 因为集合是无序的
#增加多个元素用update
set1={1,23,2}
set1.update(("你好","我很好")) # 里面必须是元组的形式
print(set1)# 结果{1, 2, '我很好', '你好', 23} #集合的删除remove discard
set1={1,23,2}
set1.discard(23)
print(set1)#结果 {1, 2} 
# discard和remove的用法和效果一样 不同点在于 当要删除的元素不存时 remove会报错 但是discard不会

列表知识补充

手写列表的排序

#方法一
lst=[1,34,56,34,57,3,55]
for i in range(len(lst)):for j in range(len(lst)):if lst[i]<lst[j]:lst[i],lst[j]=lst[j],lst[i] # 位置调换
print(lst) # [1, 3, 34, 34, 55, 56, 57]#方法二
li=[2,4,6,79,9,4,9,34,325,]
#for j in range(len(li)):
for i in range(len(li)-1):if li[i]>li[i+1]:li[i],li[i+1]=li[i+1],li[i]
print(li) # [2, 4, 6, 9, 4, 9, 34, 79, 325]#方法三
li=[2,4,6,79,9,4,9,34,325,]
for j in range(len(li)):for i in range(len(li)-1):if li[i]>li[i+1]:li[i],li[i+1]=li[i+1],li[i]
print(li)# [2, 4, 4, 6, 9, 9, 34, 79, 325]# 找水仙花数  水仙花数是一个三位数, 三位数的每一位的三次方的和还等于这个数
for i in range(100,1000):number=ic=[]for i in str(number):a=int(i)**3c.append(a)if c[0]+c[1]+c[2]==int(number):print("yes",number)

一边循环一边删除

li=[11,22,33,44]
for i in li:li.remove(i)
print(li) # [22, 44] 
# 原因在于底层指针记录循环第几号元素li=[11,22,33,44]
count=0
for i in range(0,len(li)):del li[i]count+=1if count==2:break
print(li)# [22, 44] 
# 所以尽量不要用for循环删除元素

列表深拷贝和潜拷贝

# 先看两个函数 id 和 is
a=1232346
b=a
print(id(a))# 结果 2347687314992
print(id(b))# 结果 2347687314992
print(a is b)# 结果 True
# id 是用于看变量存储的地址
# is 是用于判断两个变量的地址是否一样 一样则返回Ture# 对于列表
lst=[11,22,33,44]
lst1=llst=[11,22,33,44]
lst1=lst
print(lst is lst1) # 结果 True   #说明lst和lst1 这两个列表指向同一个地址lst1[1]="你好"  # 这个时候我们对任一个列表进行修改 我这里修改的是lst1
print(lst is lst1) # Ture 结果任然为True 说明两个列表同时同时指向一个地址没变
print(lst1) #结果 [11, '你好', 33, 44] # 我们刚刚对lst1修改了一下 
print(lst)  #解雇 [11, '你好', 33, 44] # lst并没有修改 但是也变了
# 以上说明 指向同一个地址的列表 	其中任意一个修改 指向该地址的其他列表也会一起进行修改 这就叫左潜拷贝# 上面我们讲到fromkeys函数 我们再来看看
dic=dict.fromkeys(["k1","k2","k3"],["zhou","zhang"])
print(dic) # {'k1': ['zhou', 'zhang'], 'k2': ['zhou', 'zhang'], 'k3': ['zhou', 'zhang']}
# 可以很明显的看出 dic这个字典每一个键对应的值都在 都是同一个列表 记住是同一个 不是相同 即这写列表都指向同一个地址
#我们接下来对其中一个键的值进行修改 看看结果dic["k1"].append("你好") # 我们选了第一个键进行修改
print(dic)# {'k1': ['zhou', 'zhang', '你好'], 'k2': ['zhou', 'zhang', '你好'], 'k3': ['zhou', 'zhang', '你好']}
#我们发现每一个键对应的值都被修改了#我们再来看一个案例
a=[{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09}]
b={}
c=[]
for i in a:for j,p in i.items():b[j]=pc.append(b)print(b)
print(c)
# print(b)输出的结果：{'name': 'IBM', 'shares': 100, 'price': 91.1}
#                     {'name': 'AAPL', 'shares': 50, 'price': 543.22}
#                    {'name': 'FB', 'shares': 200, 'price': 21.09}
# print(c)的结果[{'name': 'FB', 'shares': 200, 'price': 21.09}, 
#                {'name': 'FB', 'shares': 200, 'price': 21.09}, 
#                {'name': 'FB', 'shares': 200, 'price': 21.09}]
c
#由上我们看出每一次打印的b都不一样 b存进了列表c 每一次存进去的元素都不一样 但是最后c的每一个元素都一样 这就是潜拷贝的原因