一. 字符串函数
-
字符串的查找检查
mystr = “hello world itcastPython anditcastCpp”
index() :遍历 mystr查找子串,返回找到的第一个子串的起始下标,否则报错
print(mystr.index(“itcast”))
print(mystr.index(“haha”))
print(mystr.index(“itcast”, 13))
print(mystr.index(“itcast”, 13,28))find() :遍历mystr 查找子串,返回找到的第一个子串的起始下标,否则返回 -1
print(mystr.find(“itcast”))
print(mystr.find(“haha”))
print(mystr.find(“itcast”, 13))
print(mystr.find(“itcast”, 13,28))count(): 遍历mystr 查找子串,返回子串的个数
print(mystr.count(“itcast”))
print(mystr.count(“haha”))python中str函数isdigit、isdecimal、isnumeric的区别
num = “1” #unicode
num.isdigit() # True
num.isdecimal() # True
num.isnumeric() # Truenum = “1” # 全角
num.isdigit() # True
num.isdecimal() # True
num.isnumeric() # Truenum = b"1" # byte
num.isdigit() # True
num.isdecimal() # AttributeError ‘bytes’ object has no attribute ‘isdecimal’
num.isnumeric() # AttributeError ‘bytes’ object has no attribute ‘isnumeric’num = “IV” # 罗马数字
num.isdigit() # True
num.isdecimal() # False
num.isnumeric() # Truenum = “四” # 汉字
num.isdigit() # False
num.isdecimal() # False
num.isnumeric() # True======================================
isdigit()
True: Unicode数字,byte数字(单字节),全角数字(双字节),罗马数字
False: 汉字数字
Error: 无isdecimal()
True: Unicode数字,,全角数字(双字节)
False: 罗马数字,汉字数字
Error: byte数字(单字节)isnumeric()
True: Unicode数字,全角数字(双字节),罗马数字,汉字数字
False: 无
Error: byte数字(单字节)str1 = “12345”
isdigit(): 判断str1是否是整数组成,如果是返回True,否则返回False
num = input("input a number: ")if num.isdigit():
print(“数字正常”)
else:
print(“不合格,必须全部是整数”)
print(str1.isdigit())str2 = “abcdefABCDdwf”
isalpha():判断str2是否有纯字母组成,如果是返回True,否则返回False
print(str2.isalpha())isspace(): 判断str3是否由空格组成,如果是返回True,否则返回False
str3 = " "
print(str3.isspace())startswith(): 判断mystr是否以指定子串起始,如果是返回True,否则返回False
print(mystr.startswith(“hel”))endswith() : 判断mystr 是否以指定子串结尾,如果是返回True, 否则返回False
print(mystr.endswith(“Cpp”)) -
字符串的替换与分割
‘’’
Python的数据类型:
可变数据类型:列表, 字典,集合
不可变数据类型: 整型,浮点型,字符串,元组
‘’’
mystr = " hello world itcastPython and itcastCpp "
replace(): 替换mystr中指定的子串为另一个字符串,返回替换后的新字符串(先拷贝再修改并返回,原字符串不变)
str1 = mystr.replace("itcast","itheima")
print(mystr.replace("",""))
print(mystr)
print(str1)
strip(): 去除首尾空格,lstrip() 去除左边的空格, rstrip() 去除右边的空格
print(mystr.strip())
split(): 按指定的分隔符分隔字符串,并返回分隔后的列表(可以很方便的把字符串转为列表,会丢失分隔符)
print(mystr)
print(mystr.strip().split(" "))
lower(): 将mystr的所有字母转换为小写字母
print(mystr.lower())
upper(): 将mystr的所有字母转换为大写字母
print(mystr.upper())
upperswapcase() : 将mystr中所有字母 大小写 互转
print(mystr.swapcase())
capitalize() : 将mystr的第一个字符大写,其他的全部小写。
print(mystr)
print(mystr.strip().capitalize())
title(): 将mystr的所有单词的首字母大写,其他全部小写
print(mystr.title())
partition(): 将mystr按指定的子串分隔为三部分,子串前为一部分,子串为一部分,子串后为一部分(返回值为一个包含三个元素的元组)
print(mystr)
print(mystr.partition(" and")[1])
center(): 给定一个长度,将mystr居中对齐(长度要大于mystr的字节长度)
print(mystr.center(100))
len(): 查看mystr所占的元素的个数
print(len(mystr))
二. 列表函数
-
列表数据的增加
name_list = [“damao”, 20, 18]
printinsert():向列表指定的下标插入一个数据,原数据和原数据之后的数据默认后移一位
name_list.insert(2, “ermao”)
print(name_list)append():在列表某尾追加一个任何类型的数据(区别extend,列表不做拆分)
name_list.append(“sanmao”)
name_list.append(16)
name_list.append([100, 200, 300])
print(name_list)extend():在列表某尾追加一个数据,如果是列表类型则拆分后,依次将数据追加到列表里
name_list.extend([“simao”, 14,“wumao”, 12])
print(name_list) -
列表数据的查询
name_list = [‘damao’, 20, ‘ermao’, 18,‘sanmao’,
16, [100, 200, 300], ‘simao’, 14, ‘wumao’, 12]
in / not in :判断数据是否存在,返回bool值如果"ermao" 在列表中,则打印
if “ermao” in name_list:
print(“ermao在这,快抓住它!”)如果不存在,则追加"ermao"
else:
name_list.append(“ermao”)index() : 返回列表里指定元素的下标(如果没有,则报错)
name = “sanmao”
if name in name_list: # 如果"sanmao"在列表中,则打印其索引值
index = name_list.index(“sanmao”)
print(index)
else: # 否则提示数据不存在
print(“数据不存在!”)count(): 返回列表里指定元素的个数(如果没有,返回0)
print(name_list.count(18)) # 返回列表里 18 的个数 -
列表的修改与删除
name_list = [‘damao’, 20, ‘ermao’, 18,‘sanmao’,16, [100, 200, 300], ‘simao’, 14, ‘wumao’, 12]
print(name_list)数据的修改: 根据元素下标,直接重新赋值
name_list[6] = [10, 20, 30]
print(name_list)if [100, 200, 300] in name_list:
name_list[name_list.index([100, 200, 300])] = “Hello List”
else:
print(“数据不存在!”)
print(name_list)数据的删除
remove() : 删除列表内指定的元素,如果元素不存在则报错
name_list.remove(“Hello List”)
print(name_list)pop() : 删除列表内指定的下标的数据,并返回该数据(如果没有参数,则默认操作最后的数据)
name1 = name_list.pop(5)
print(name1)
print(name_list)name2 = name_list.pop()
print(name2)
print(name_list)clear():清空列表所有的数据,但不删除列表
name_list.clear()
name_list = []
print(name_list)del (Python提供的删除方式):可以删除任何数据,或者是列表里的某个下标的元素
del name_list[0]
print(name_list)
del name_list
print(name_list) -
列表的排序的逆置
sort() : Python 列表提供的方法,在原列表基础上排序,会修改原列表
Python2 支持混合数据的列表[10, ‘abcd’, 3.14, ‘ABCD’]
Python3 不支持混合数据的列表num_list = [123, 10, 0, -5, 100]
print(num_list)默认 从小到大 排序
num_list.sort()
print(num_list)参数 reverse = True,表示从大到小 排序(默认 reverse = False)
num_list.sort(reverse=True)
print(num_list)BIF : sorted(): Python提供的方法,返回排序后的新列表,原列表不变
str_list = [“aBCD”,“caaa”, ‘Adafew’] # 如果数据是字符串类型,则根据每个字符串的首字母的ASCII码比较默认 从小到大 排序
sortedstr_list1 = sorted(str_list)
print(sortedstr_list1)
print(str_list)
同样的,reverse =True 表示从大到小 排序
sortedstr_list2 = sorted(str_list,reverse=True)
print(sortedstr_list2)reverse(): 将列表逆置
print(num_list)
num_list.reverse()
print(num_list) -
列表的拷贝
num_list = [10, 20, 30]
num_list1 = num_list # 浅拷贝:只是增加了一个数据的引用,任何引用修改数据,其他引用也对应修改所有引用共享同一个内存的数据
num_list[1] = 200
print(num_list)
print(num_list1)copy():深拷贝,拷贝一份数据给一个新的列表,和原列表没有任何关系
两个列表不共享内存数据,各自独立
newnum_list = num_list.copy()
print(num_list)
print(newnum_list) -
列表的推导式
比较 Pythonic 的列表处理
生成一个 1 ~ 21 之间所有偶数的列表直接创建列表
num_list1 = [2, 4, 6, 8, 10, 12, 14, 16,18, 20]
print(num_list1)利用range() 函数生成等差数列
num_list2 = list(range(2, 21, 2))
print(num_list2)while 循环
num_list3 = []
i = 2
while i <= 20:
if i % 2 == 0:
num_list3.append(i)
i+= 1
print(num_list3)for 迭代 + range()
num_list4 = []
for i in range(1, 21):
if i % 2 == 0:
num_list4.append(i)
print(num_list4)列表推导式(列表生成式) : 创建列表 / 处理列表数据
num_list5 = [i for i in range(1, 21) if i %2 == 0]
“”"
for i in range(1, 21):
if i % 2 == 0:
num_list4.append(i)
“”"
print(num_list5)生成一个 1 ~ 21 之间所有偶数的平方的列表
num_list6 = [i ** 2 for i in range(1, 21)if i % 2 == 0]
print(num_list6)生成 10 个 “666” 的列表
num_list7 = [“666” for _ inrange(10)]
print(num_list7)[‘damao’, 10, ‘ermao’, 20] 获取列表里长度大于3的字符串
lis = [‘damao’, 10, ‘ermao’, 20]
num_list8 = [i for i in lis if len(str(i))> 3]
print(num_list8)[i for i in range(10) i = 10] 错误,for in 后面只能跟 if
[x for x in list if True]a = [lambda: x for x in range(1, 10) ]
print(a)
print(a0) -
列表的使用技巧
列表的合并
list1 = [10, 20, 30]
list2 = [‘a’, ‘b’, ‘c’]
list3 = list1 + list2 # list2 的数据在 list1 后面追加,并生成了一个新列表
print(list3)
print(‘list1的id:%s, list3的id: %s’ % (id(list1), id(list3)))等同 extend() : list1.extend(list2)
list1 += list2 # list2 的数据在list1 后面追加,但是不会生成新列表,数据全部在list1里面
print(id(list1))" ".join() 将列表转换为字符串
字符串转列表:
mystr = “hello world hellopython!”
str_list = mystr.split(" ") # 按分隔符转换为列表
print(str_list)
print(list(mystr)) # list(str) 将字符串每个字符当成列表的一个元素,转换为列表列表转字符串:
print(str_list)
print("".join(str_list)) # " ".join() 默认只能将全是字符串的列表 转成字符串num_list = [10, 20, 30]
print(" ".join(num_list)) # 报错:非字符串部分不能转换其他数据类型的列表 转 字符串
[num_list = 10.10, 20,30, “string”] # 其他数据类型的列表
print(num_list)print(" ".join([str(num) for numin num_list])) # 通过列表推导式,将每个元素通过str()处理后再转换
numstr_list = [str(i) for i in num_list]
num_str = " ".join(numstr_list)
print(num_str)BIF 类型判断:isinstance(): 可以判断对象是否是指定的类型,如果是则返回True,否则返回False
printpassword = input(“请输入密码:”)
if isinstance(password, str):
print(“password 是字符串”)
elif isinstance(password, int):
print(“password 是整型…”)
else:
print(type(password))
num_list = [12, 34, [100, 200, 300], 56,78, [400, 500, 600]]
for num in num_list:
if isinstance(num, list): # 判断num 是否是一个列表,如果是,则继续迭代取值
for i in num:
print(i)
else: # 否则直接打印
print(num)
BIF : enumerate(list, tuple ....): 返回一个列表,包含了原列表的元素下标 和 元素 的元组。
num_list2 = [10, 20, 30, 40, 50, 60]
enumerate() 枚举,可以让我们通过元素下标来处理数据 (拆包)
enumerate(num_list2) == [(0, 10), (1, 20),(2, 30), (5, 60)]
for index, value in enumerate(num_list2):
if index % 2 == 0:
print(index, value)
for i in enumerate(num_list2):
print(i)
三. 元组的查询统计
tuple()
-
通过range() 创建
t1 = tuple(range(10, 20, 2))
print(t1) -
直接创建元组
t2 = (20, 30, 40, 50)
print(t2)t3 = (100, ) # 只有一个元素的时候,要加 ,
print(t3)
print(type(t3)) -
并没有元组推导式,但是会返回一个可迭代对象
t4 = (i for i in range(20) if i % 2 == 0)
for i in t4:
print(i)t5 = (100, 200, 300, 200, 100, [10, 20, 30], ‘hello Python’)
index(): 返回指定元素的 下标值(如果没有,则报错)
num = t5.index(“hello Python”)
print(num) -
元组的修改:元组本身元素不可修改
t5[6] = “Hello World!”
print(t5)num_list = t5[5]
num_list[1]元组的元素不可变(元组的某个元素如果可变,那么也可以修改数据)
不代表元组的元素不可变。
t55 = 200
print(t5)count() : 返回指定元素的个数,如果没有则返回0
print(t5.count(200))
四. 字典(dictionary)
-
字典的获取删除
字典数据的添加
根据键名添加或修改
name_dict = {}
print(name_dict)name_dict[‘name’] = “python” # 如果字典没有这个键,则创建这个键值对
print(name_dict)name_dict[‘name’] = “hello” # 如果字典有这个键,则重新赋值
print(name_dict)setdefault() :
print(name_dict.setdefault(“name”)) # 如果有这个键,则返回这个键对应的值
print(name_dict.setdefault(“age”)) # 如果没有这个键,则返回 None,同时创建这个键值对,默认值是None
print(name_dict.setdefault(“id”,110)) # 如果没有这个键,则创建这个键和指定值的 键值对,并返回指定的值
print(name_dict)keys() : 返回这个字典的所有的键 的列表(返回类型为:class’dict_keys’,需通过list()转换)
print(list(name_dict.keys()))
print(name_dict[‘test’])
if “test” in name_dict.keys():
print(“name存在 %s” %name_dict[“test”])
else:
print(“test 未找到”)values(): 返回这个字典的所有的值 的列表()(返回类型为:class ‘dict_values’,需通过list()转换)
print(name_dict.values())
for value in name_dict.values():
print(value)items(): 返回这个字典的所有的 键值对(元组) 的列表(返回类型为:class’items’,需通过list()转换)
print(list(name_dict.items()))
for key, value in name_dict.items():print(key, value)
get() 返回指定键的值,如果没有这个键,默认返回None,如果指定第二个参数,则返回参数值
print(name_dict)
print(name_dict.get(“name”))
print(name_dict.get(“test”))
print(name_dict.get(“test”,False)) # get() 不会创建键值对,setdefault() 会创建name_dict.setdefault(“name”) # 如果有这个键,则返回键对应的值,否则创建键值对,默认值为None
name_dict.setdefault(“test”,1234) # 如果指定了第二个参数,则创建键值对的值为 参数值
print(name_dict[“name”]) # 如果有这个键,返回值;如果没有,则报错if name_dict.get(“test”):
print(name_dict[“test”])
else:
print(“test 不存在!”)update : 更新info_dict 的内容,参数是一个dict类型。
不仅覆盖已有的数据,还能新增没有的数据
info_dict = {“name”:“python”, “age”: 26, “id”: 110, 0:“number”}
newinfo_dict = {“name”:“hello”, “id”: 119}
print(newinfo_dict)
newinfo_dict.update(info_dict)
print(newinfo_dict) -
字典的拷贝
name_dict = {“name”:“python”, “age”: 26, “id”: 110, 0:“number”}
copy(): 深拷贝字典,创建一个新的字典对象,而非引用
import copy
newname_dict =copy.deepcopy(name_dict) # 内存层深拷贝,拷贝全新的数据
newname_dict = name_dict.copy() # 创建一个新字典,而非引用 -
字典的删除
pop() : 参数是键,删除指定的键值对,并返回值 (第二个参数表示如果没有这个键,则返回这个参数值)
name = newname_dict.pop(“name”) # “name” 键存在,返回"name"对应的值
print(name)
print(newname_dict)
name =newname_dict.pop(“newname”, “hello”) # “newname” 不存在,返回 “hello”
print(name)
print(newname_dict)popitem() : 依次 从后向前 删除键值对,并返回这个键值对的元组
key, value = newname_dict.popitem() # 拆包(拆分元组,并用变量接收)
print(key)
print(value)key_list = []
value_list = []
for i in range(len(newname_dict)):
key, value = newname_dict.popitem()
key_list.append(key)
value_list.append(value)
print(key_list)
print(value_list)
print(newname_dict)
newname_dict.popitem()clear() : 清空字典的数据,但不删除字典
newname_dict.clear()
print(newname_dict)del() / del
del(newname_dict)
print(“hahah”)
print(newname_dict)
print(name_dict) -
字典推导式
列表推导式
num_list = [i for i in range(1, 21)] # 返回数据时,不需要处理为键值对
print(num_list)字典推导式
num_dict = {i: i ** 2 for i in range(1,21)} # 返回数据时,处理键值对结果
print(num_dict)将两个列表的元素 合并为一个 字典
key_list = [“name”,“age”, “id”]
value_list = [“python”, 18, 110]
name_dict = {key_list[i]: value_list[i] fori in range(len(key_list))}
print(name_dict)将字典转换为 两个列表,分别存储 key和value
key_list1 = []
value_list1 = []
for key, value in name_dict.items():
key_list1.append(key)
value_list1.append(value)
print(key_list1)
print(value_list1)字典的键值对 互相转换
print(name_dict)
newname_dict = {value: key for key, valuein name_dict.items()}
print(newname_dict)
五. 集合的使用
集合 、 列表、 元组 可以互相转换
集合里的数据都是唯一的,没有重复的数据
-
创建集合
num_dict = {} # 创建空字典
num_set = set() # 创建空集合print(type(num_set))
set(list) 最常用的集合处理,把列表转成集合
set.add() : 向集合里添加一个数据
num_list = [10, 23, 43, 23, 10, 0, -10, 0]
print(list(set(num_list))) # 将列表快速去重
num_set = {10, 20, 30,20, 30, 10, 100}
print(num_set)print字典和集合都是无序的,1. 不支持下标索引, 2.不支持排序
print(sorted(num_set)) # 先转成了列表,再排序,所以排序结果是一个列表 -
添加数据:
add() : 向集合里添加一个数据
num_set.add(200)
print(num_set)
print(num_set[2])update() :向集合里添加多个数据(参数是一个列表,把列表里的每个元素添加到集合里)
num_set.update([500, 600, 700])
print(num_set) -
删除数据:
remove(): 删除指定的数据,remove 删除指定数据,数据不存在则报错
num_set.remove(600)
print(num_set)discard() : 删除指定的数据,如果数据不存在,则不会做任何操作
print(“nothing”)
num_set.discard(6000)
print(num_set)pop() : 删除指定数据(默认从头部开始删除并返回),并返回该数据
num = num_set.pop()
print(num)
print(num_set)如果有需要,一般集合都会转成列表做复杂操作,然后再转回集合
-
集合推导式 ( Python里的三个推导式:列表推导式、字典推导式、集合推导式)
set1 = {i for i in range(1, 5, 1)}
set2 = {i for i in range(2, 6, 1)}
print(set1)
print(set2) -
交集 : 两个集合 共有的部分
print(set1 & set2)
-
并集 : 合并两个集合,并去重
print(set1 | set2)
-
差集 :
print(set1 - set2) # set1 有的但是set2 没有的
print(set2 - set1) # set2 有的但是set1 没有的