python基础(二)
基本数据类型
1. int 数字
a = 10 print(a,type(a))答案： 10 int1.1 数字十进制转出二进制
a = 53 转换成二进制就是： 0011 0101
1.2 二进转十进制
0100 1010 num = 1* 2**1 + 1*2**3 + 1* 2**6 num = 74
进制转换在线工具：https://tool.lu/hexconvert/
2、布尔值 bool
True False
3、字符串 str
双引号或单引号引起来的都是字符串
索引、切片：course_name = "Python从入门到精通" # 取索引为0的值 print(course_name[0]) # 取索引0到6的值， 注意：顾头不顾尾 print(course_name[0:6]) # 取索引0到6的值，步长为2 print(course_name[0:6:2]) # 取最后到-5的位置，步长为-1 print(course_name[-1:-5:-1]) # 取-6到最后的值 print(course_name[-6:]) 答案： P Python Pto 通精到门 从入门到精通字符串的常用方法
# upper lower s1 = "DengHuoQiTan" s2 = s1.upper() print(s2) s3 = s1.lower() print(s3) 答案： DENGHUOQITAN denghuoqitan # startswith endswith s1 = "BaoboJack_alex" s2 = s1.startswith("B") print(s2) # True s3 = s1.endswith('_') print(s3) # False s4 = s1.endswith("alex") print(s4) # True s4 = s1.startswith('bo',4,8) print(s4) # False s5 = s1.startswith('bo',3,8) print(s5) # True # replace s1 = "bob是一个高级工程师，bob喜欢打球，bob很man" s2 = s1.replace("bob","job") print(s2) # "job是一个高级工程师，job喜欢打球，job很man" s3 = s1.replace('bob','job',2) print(s3) # "job是一个高级工程师，job喜欢打球，bob很man" # split names = "job bob alex" # split默认以空格分隔，可以指定分隔符 names1 = names.split() print(names1) # ['job', 'bob', 'alex'] 列表 names = "job:bob:alex" names2 = names.split(":") print(names2) # ['job', 'bob', 'alex'] 列表 names = ":job:bob:alex" names3 = names.split(":") print(names3) # ['', 'job', 'bob', 'alex'] 列表# 用split做的计算器import re
content = input("请输入内容:")
num_list = re.split(" |\+|\-|\*|\/",content)
new_list= []
for num in num_list:
if num:
new_list.append(num)
print(new_list)
for i in new_list:
i = i.replace(' ','')
if i.isdecimal():
continue
else:
print("%s不是数字"%i)
break
else:
print(eval(content.replace(' ','')))# join # 可以把任何的可以迭代的对象连接起来,前提是可迭代的对象不能是数字 s1 = "jobissb" s2 = "_".join(s1) print(s2,type(s2)) # j_o_b_i_s_s_b <class 'str'> i1 = ["aa",'bb',"cc"] i1_str = "+".join(i1) print(i1_str) # aa+bb+cc i2 = ["aa",'bb',22] # 此处元素不能是数字 i2_str = "+".join(i2) print(i2_str) ''' 报错： File "F:/python_project/day2/s2 str.py", line 55, in <module> i2_str = "+".join(i2) TypeError: sequence item 2: expected str instance, int found '''# strip 去除空格 、\t 、\n
s1 = " alex bob "
s2 = s1.strip()
print(s2) # alex bob 中间的空格没有去除
s3 = s1.replace(" ","")
print(s3) # alexbob 所有的空格都去除# count
s1 = "kdjfdasklfjsaafdafafde"
num = s1.count("k")
print(num) # 2 类型：int
# format
# 第一种用法
a = "我的名字叫{},今年{}岁,我来自{}".format("周润发",28,"中国")
print(a) # 我的名字叫周润发,今年28岁,我来自中国
# 第二种用法
b = "我的名字叫{0},今年{1}岁,我来自{2},我依然叫{0}".format("周润发",28,"中国")
print(b) # 我的名字叫周润发,今年28岁,我来自中国,我依然叫周润发
# 第三种用法
c = "我的名字叫{name},今年{age}岁,我来自{country}".format(age=18,country="中国",name="江鱼儿")
print(c)# is系列
name = "alex123"
# isalpha 判断是否全部只有字母
print(name.isalpha()) # False
# isalnum 判断是否是有字母和数字组成
print(name.isalnum()) # True
# isdecimal 判断是否为10进制
print(name.isdecimal()) # False
# 例如
num = input("请输入数字：")
if num.isdecimal():
print(num)
else:
print("您输入有误！！！")答案：请输入数字：32
32练习题：自动算加减法算式
content = input("请输入算式：") num_list = [] i = 0 for i in content.split("+"): if "-" not in i: num_list.append("+%s"%i) else: for index,j in enumerate(i.split("-")): if index == 0: num_list.append("+%s"%j) else: num_list.append("-%s"%j) print(num_list) sum = 0 for num in num_list: if num.startswith("+"): num_zheng = num.replace("+","") if num_zheng.isdecimal(): sum += int(num_zheng) if num.startswith("-"): num_fu = num.replace("-","") if num_fu.isdecimal(): sum -= int(num_fu) print(sum)答案：请输入算式：20+8-60+20+80
['+20', '+8', '-60', '+20', '+80']
68补充：
# capitalize # s1 = "abcd" # print(s1.capitalize()) # Abcd 首字母大写# title
s4 = "this is car"
print(s4.title()) # This Is Car 单个单词首字母大写 # swapcase # s2 = "abcdGDse" # print(s2.swapcase()) # ABCDgdSE 大小写转换 # center # ret = s2.center(30,"_") # print(ret) # ___________abcdGDse___________ 长度30并居中，其他位置用 _ 填充 # count # s3 = "abcdGDaseabcd" # print(s3.count('a')) # 3 计算字符a在s3出现的次数 # find index # print(s3.find('d')) # 3 查询字符d在s3的索引位置 # print(s3.find('d',4,13)) # 12 查询字符d在s3中4-13中的哪个位置 # print(s3.find('o')) # -1 找不到返回-1 # index # print(s3.index('d')) # 3 查询字符d在s3的索引位置 # print(s3.index('d',4,13)) # 12 查询字符d在s3中4-13中的哪个位置 # print(s3.index('o')) # 报错# 总结：find和index几乎一样，不同的是：find找不到返回-1，index找不到会报错
4、列表 list
基础知识：
1. 列表可以承载任意数据类型，存储大量的数据
2. pyton常用的容器性数据类型
3. 列表是有序的，可以按照索引切片
# 索引 # 切片（顾头不顾尾） l2 = [1,3,2,"a",4,"b",5,"c"] print(l2[:3]) print(l2[3:6]) print(l2[1:-2:2]) print(l2[-3:0:-2]) 答案： [1, 3, 2] ['a', 4, 'b'] [3, 'a', 'b'] ['b', 'a', 3]# 创建 3种方式# 增删改查# 增# l1 = ["张三","李四","王五"]
# while 1:
# name = input("请输入新员工名字(输入'Q'或者'q'退出程序):")
# if name.upper() == "Q":
# break
# l1.append(name)
# print(l1)
# insert
# l1 = ["张三","李四","王五","陆六"]
# l1.insert(1,"刘麻子")
# print(l1)# extendli = ["alex","Wusir","ritian","barry","wenzhou"]
# 请将列表l2 = [1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现
l2 = [1,"a",3,4,"heart"]
li.extend(l2)
print(li)
# 删
# pop
# l1 = ["张三","李四","王五","陆六"]
# res = l1.pop(-2)
# print(res)
# print(l1)
# remove
# l1 = ["张三","李四","王五","陆六"]
# l1.remove("李四")
# print(l1)
# clear
# l1 = ["张三","李四","王五","陆六"]
# l1.clear()
# print(l1)
# del
# l1 = ["张三","李四","王五","陆六"]
# del l1[::2]
# print(l1)
# 改
# l1 = ["张三","李四","王五","陆六"]
# l1[0] = "柴七"
# print(l1)
# l1 = ["张三","李四","王五","陆六"]
# l1[1:] = ["alex","wusir"]
# print(l1)# 查 for循环l1 = ["张三","李四","王五","陆六"]
for i in l1:
print(i)答案：张三
李四
王五
陆六练习题
li = ["alex","Wusir","ritian","barry","wenzhou"] # 计算列表的长度 print(len(li)) # 5 # 列表中追加元素“seven”,并输出添加后的列表 li.append("seven") print(li) # ['alex', 'Wusir', 'ritian', 'barry', 'wenzhou', 'seven'] # 请在列表第1个位置插入元素"Tony",并输出添加后的列表 li.insert(1,"Tony") print(li) # ['alex', 'Tony', 'Wusir', 'ritian', 'barry', 'wenzhou'] # 请修改第2个位置的元素为"Kelly",并输出修改后的列表 li[2] = "Kelly" print(li) # ['alex', 'Wusir', 'Kelly', 'barry', 'wenzhou']# 请将列表l2 = [1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现
l2 = [1,"a",3,4,"heart"]
li[5:] = l2
print(li) # ['alex', 'Wusir', 'ritian', 'barry', 'wenzhou', 1, 'a', 3, 4, 'heart']# 请将字符串 s = "qwert" 的每一个元素添加到列表li中，一行代码实现
s = "qwert"
li[5:] = s
print(li) # ['alex', 'Wusir', 'ritian', 'barry', 'wenzhou', 'q', 'w', 'e', 'r', 't']# 请删除列表中的元素 "ritian",并输出删除后的元素
li.remove("ritian")
print(li) # ['alex', 'Wusir', 'barry', 'wenzhou']# # 请删除列表中第2个元素 ，并输出删除的元素和删除后的列表
pop_val = li.pop(2)
print(pop_val) # ritian
print(li) # ['alex', 'Wusir', 'barry', 'wenzhou']# 请删除列表中的第2至4个元素 ,并输出删除后的列表
del li[2:4]
print(li) # ['alex', 'Wusir', 'wenzhou']li = [1,2,"taibai",[1,"alex",3,]]
# 将li中的"taibai"变成大写并放回原处
li[2] = li[2].upper()
print(li) # [1, 2, 'TAIBAI', [1, 'alex', 3]]li = [1,2,"taibai",[1,"alex",3,]]
# 给小列表[1,'alex',3,]追加一个元素，'老男孩教育'
li[-1].append("老男孩教育")
print(li) # [1, 2, 'taibai', [1, 'alex', 3, '老男孩教育']]li = [1,2,"taibai",[1,"alex",3,]]
# 将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'
li[-1][1] = li[-1][1] + "sb"
print(li) # [1, 2, 'taibai', [1, 'alexsb', 3]]补充：
# count # l1 = [2,3,7,8,3,3,3,8,9,2] # print(l1.count(3)) # 4 count计算3在l1中出现的次数 # index # print(l1.index(8)) # 3 idnex查询8在l1中第一次出现的索引位置 # l2 = [3,5,8,1,3,9,0,7,6] # l2.sort() # print(l2) # [0, 1, 3, 3, 5, 6, 7, 8, 9] sort给l2进行从小到大排序 # l3 = [3,5,8,1,3,9,0,7,6] # l3.sort(reverse=True) # print(l3) # [9, 8, 7, 6, 5, 3, 3, 1, 0] sort里面加个reverse进行从大到小排序 # l4 = [3,5,8,1,3,9,0,7,6] # l4.reverse() # print(l4) # [6, 7, 0, 9, 3, 1, 8, 5, 3] reverse就是把l4的顺序反过来 # 列表与列表相加 l1 = [1,2,3] l2 = [2,3,4,5,6] # print(l1+l2) # [1, 2, 3, 2, 3, 4, 5, 6] 列表与列表相加 # 列表与数字相乘 l3 = [1,2,3] print(l3*5) # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]补充练习题
# 坑 # 删除一下列表索引位置是奇数的值 l1 = [11,22,33,44,55,66] # 错误： # for i in range(len(l1)-1): # if i % 2 == 1: # l1.pop(i) # print(l1) # [11, 33, 44, 66] 正确答案应该是：[11, 33, 55] why？ # 正确： # 方式1： # del l1[1::2] # print(l1) # [11, 33, 55] # 方式2 # for i in range(len(l1)-1,-1,-1): # if i % 2 == 1: # l1.pop(i) # print(l1) # [11, 33, 55] # 方式3： new_list = [] for i in range(len(l1)): if i % 2 == 0: new_list.append(l1[i]) print(new_list)总结：在循环一个列表时的过程中，如果你要改变列表的大小（增加值，或者删除值），那么结果很可能会出错或者报错。
5、元祖 tuple
基础知识：
只读列表，可以存大量的数据，可以索引，切片（步长）
只能查，不能增删改（注意：元祖的第一层元素不能而已）
应用：
# 重要数据，用户名，密码，个人信息，不想让别人改动的一些数据，存在元祖中
# 元祖的拆包，分别赋值
a,b = (1,2) print(a,b)补充：
# tuple # 注意的地方 tu1 = (2,3,4) print(tu1,type(tu1)) # (2, 3, 4) <class 'tuple'> tu2 = (3) print(tu2,type(tu2)) # 3 <class 'int'> tu2_1 = (3,) print(tu2_1,type(tu2_1)) # (3,) <class 'tuple'> tu3 = ("yu") print(tu3,type(tu3)) # yu <class 'str'> tu4 = ([1,3,5]) print(tu4,type(tu4)) # [1, 3, 5] <class 'list'> # 总结：在创建元祖时候，单个元素没有加逗号的话，创建的数据类型就是元素的数据类型，所以在创建元素的时候，如果 # 是单个元素，都在后面加个逗号 # count tu5 = (3,7,8,2,6,8,3,9,8,3) print(tu5.count(8)) # 3 count计算8在元祖tu5中出现的次数 # index print(tu5.index(9)) # 7 index是查询9在tu5中的第一次出现的索引位置
6、字典
字典：查询速度快，数据的关联性强
1、数据类型分类：
可变类型： list dict set （不可哈希数据类型）
不可变类型：str int bool tuple （可哈希数据）
2、注意：字典是有key和value键值对组成，字典的key只能是不可变类型并且唯一的，字典的value可以为任何数据类型
3、字典的创建（有三种方式）
方式一：dic = dict((("name","bob"),("age",18),("sex","男")))方式二：dic = dict({"name":"job","age":18,"sex":"男"})# 方式三
dic = dict(name="job",age=18,sex="男")4、字典的增删改查
# 增 # 方法一： 注意：存在就修改，不存在就添加 dic = dict(name="job",age=18,sex="男") dic["hobby"] = ["篮球","足球","乒乓球"] print(dic)答案：# {'name': 'job', 'age': 18, 'sex': '男', 'hobby': ['篮球', '足球', '乒乓球']}dic["age"] = 28
print(dic) # {'name': 'job', 'age': 28, 'sex': '男'}方法二：setdefault 注意：存在就不变，不存在就添加dic = dict(name="job",age=18,sex="男")
dic.setdefault("hobby",["篮球","足球","乒乓球"])
print(dic)
dic.setdefault('age',32)
print(dic)答案：{'name': 'job', 'age': 18, 'sex': '男', 'hobby': ['篮球', '足球', '乒乓球']}
{'name': 'job', 'age': 18, 'sex': '男', 'hobby': ['篮球', '足球', '乒乓球']}
# 删除
# dic = dict(name="job",age=18,sex="男")
# # del
# del dic['age']
# print(dic) # {'name': 'job', 'sex': '男'}
#
# # clear
# dic.clear()
# print(dic) # {}
# pop **
dic = dict(name="job",age=18,sex="男")
ret = dic.pop("age","没有此key") # 当key不存在时不会报错，会返回"没有此key"给ret
print(ret) # 删除的key对应的值
print(dic) # {'name': 'job', 'sex': '男'}# 改 同增方法的存在的key的赋值方法# 查方法一：通过key来查value
dic = dict(name="job",age=18,sex="男")
print(dic['name']) # job
# print(dic['hobby']) # 如果不存在的key会报错
方法二：通过get来查
print(dic.get('hobby')) # 如果不存在的key不会报错，会显示None
print(dic.get("age")) # 18# 特殊类型 keys values items# keys
dic = dict(name="job",age=18,sex="男")
print(dic.keys()) # dict_keys(['name', 'age', 'sex'])
# 通过list转换成列表
print(list(dic.keys())) # ['name', 'age', 'sex']
for key in dic.keys():
print(key)
答案：
name
age
sex
# values
print(dic.values()) # dict_values(['job', 18, '男'])
# 通过list转换成列表
print(list(dic.values())) # ['job', 18, '男']
# 通过for循环来获取每一个value
for value in dic.values():
print(value)
答案：
job
18
男# itemsdic = dict(name="job",age=18,sex="男")
print(dic.items()) # dict_items([('name', 'job'), ('age', 18), ('sex', '男')])
# 通过list转换成列表
print(list(dic.items())) # [('name', 'job'), ('age', 18), ('sex', '男')]
# 通过for循环拿到所有的元祖
for i in dic.items():
print(i)
'''
答案:
('name', 'job')
('age', 18)
('sex', '男')
'''
# 通过元祖的解包可以拿到key和value
for key,value in dic.items():
print(key,value)
'''
答案：
name job
age 18
sex 男
'''练习题
dic = {'k1':'v1',"k2":'v2',"k3":[11,22,33]} # 请在字典中添加一个键值对，"k4":"v4",输出添加后的字典 dic.setdefault("k4","v4") print(dic) # {'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'} # 请在修改字典中"k1"对应的值'alex',输出修改后的字典 dic['k1']= "alex" print(dic) # {'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'} # 请在k3对应的值中追加一个元素44 ，输出修改后的字典 dic['k3'].append(44) print(dic) # {'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'} # 请在k3对应的值的第一个位置插入一个元素18，输出修改后的字典 dic['k3'].insert(1,18) print(dic) # {'k1': 'alex', 'k2': 'v2', 'k3': [11, 18, 22, 33, 44], 'k4': 'v4'}5、字典的嵌套
dic = { 'name':'汪峰', 'age':48, 'wife':[{'name':'国际章','age':38},], 'children':{'girl_first':"小苹果","girl_second":"小怡",'girl_three':"顶顶"} } # 获取汪峰的名字 print(dic.get('name')) # 汪峰 # 获取这个字典： {'name':'国际章','age':38} print(dic.get('wife')[0]) # {'name': '国际章', 'age': 38} # 获取汪峰妻子的名字 print(dic.get('wife')[0].get('name')) # 国际章 # 获取汪峰的第三个孩子的名字 print(dic.get('children').get("girl_three")) # 顶顶练习题2
dic1 = { 'name':['alex',2,3,5], 'job':'teacher', 'oldboy':{'alex':['python1','python2',100]} } # 将name对应的列表追加一个元素'wusir' dic1.get('name').append("wusir") # 将name对应的列表中的alex首字母大写 dic1.get('name')[0] = dic1.get('name')[0].capitalize() # oldboy对应的字典加一个键值对'老男孩':'linux' dic1.get('oldboy')['老男孩'] = 'linux' # 将oldboy对应的字典中的alex对应的列表中的python2删除 del dic1.get('oldboy').get('alex')[1] print(dic1)补充：
# 创建 formkeys dic1 = dict.fromkeys('abc',100) # formkeys第一个参数是一个可迭代类型的数据，第二个可以为任意的数据 print(dic1) # {'a': 100, 'b': 100, 'c': 100} dic2 = dict.fromkeys('abc',[22,33,44]) print(dic2) # {'a': [22, 33, 44], 'b': [22, 33, 44], 'c': [22, 33, 44]} dic1 = dict.fromkeys('abcbd',100) print(dic1) # {'a': 100, 'b': 100, 'c': 100, 'd': 100} 保证key的唯一性会去重# 坑
dic1 = {'k1':'yushen','k2':18,'k3':'alex','sex':'man'}
# 删除key中包含'k'的数据
# 错误
# for key in dic1:
# if 'k' in key:
# dic1.pop(key)
# print(dic1) # 报错
# 正确
# 方式一：
# for key in list(dic1.keys()):
# if 'k' in key:
# dic1.pop(key)
# print(dic1) # {'sex': 'man'}
# 方式二：
new_list = []
for key in dic1.keys():
if 'k' in key:
new_list.append(key)
print(new_list) # ['k1', 'k2', 'k3']
for i in new_list:
dic1.pop(i)
print("dic1====>",dic1) # dic1====> {'sex': 'man'}总结：在循环一个字典的过程中，不要改变字典的大小（增，删字典的元素），这样会直接报错。# update
# update第一种方式的使用
# dic1 = {'k1':'yushen','k2':18,'k3':'alex','sex':'man'}
# dic1.update(sex='woman')
# print(dic1) # {'k1': 'yushen', 'k2': 18, 'k3': 'alex', 'sex': 'woman'}
#
# dic1.update(name='wusir')
# print(dic1) # {'k1': 'yushen', 'k2': 18, 'k3': 'alex', 'sex': 'woman', 'name': 'wusir'}
# 总结：update对字典操作，有则覆盖，无则添加
# update的第二种方式的使用
# dic1.update([(1,'num1'),(2,'num2')])
# print(dic1) # {'k1': 'yushen', 'k2': 18, 'k3': 'alex', 'sex': 'man', 1: 'num1', 2: 'num2'}
# update的第三种方式的使用
# dic1 = {'k1':'yushen','k2':18,'k3':'alex','sex':'man'}
# dic1.update({'k4':'numk4','k5':'numk5'})
# print(dic1) # {'k1': 'yushen', 'k2': 18, 'k3': 'alex', 'sex': 'man', 'k4': 'numk4', 'k5': 'numk5'}
7、集合 set
容器型的数据类型，它要求它里面的元素是不可变的数据（可哈希），但是它本身是可变的数据类型。集合是无序的。｛｝。
集合的作用：1、列表的去重 2、关系的测试：交集、并集、差集….
# 集合的创建 # 方法一： # set1 = set({1,3,True,'alex'}) # print(set1,type(set1)) # 方法二 # set1 = {1,3,True,"alex"} # print(set1) # 增删改 # 增 add # set1 = {1,3,True,"alex"} # set1.add("wusir") # print(set1) # 删 pop remove clear del # pop 随意删一个值 # set1.pop() # remove 通过值来删除 # set1.remove("alex") # clear 清空集合 # del 把整个集合给删除 # del set1# 交集 （& 或 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)
print(set1.intersection(set2))
# 并集 (| union)
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)
print(set1.union(set2))# 差集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1-set2) # set1中有的，set2中没有的
print(set1.difference(set2))
# 反交集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)
print(set1.symmetric_difference(set2))
# 子集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1<set2) # set1是不是set2的子集,意思是set1的元素是不是都在set2中
print(set1.issubset(set2))
# 超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set2 > set1) # set2是不是set1的超集，意思是set2是不是包含了set1
print(set2.issuperset(set1))
8、range
类似于列表，自定制数字范围的数字列表
基础数据类型分类
按存储空间的占用分（从低到高）
数字 字符串 集合：无序，即无序存索引相关信息 元组：有序，需要存索引相关信息，不可变 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改 字典：有序，需要存key与value映射的相关信息，可变，需要处理数据的增删改（3.6之后有序）
按存值个数区分
| 标量/原子类型 | 数字，字符串 |
| 容器类型 | 列表，元祖，字典 |
按可变不可变区分
| 可变 | 列表、字典 |
| 不可变 | 数字，字符串，元祖，布尔值 |
按访问顺序区分
| 直接访问 | 数字 |
| 顺序访问（序列类型） | 字符串，列表，元祖 |
| key值访问（映射类型） | 字典 |
------------- end ----------------------------
对于一个有思想的人来说，没有地方是荒凉而遥远的
