一、数字
1.将字符串转换为数字
a = "123"
print(type(a)) # type()可以查看元素类型
b = int(a)
print(type(b))
## 执行结果为
## <class 'str'>
## <class 'int'>
2.进制转换
num = "0011"
v = int(num, base=2) # 将num的值二进制转换为int型的值
print(v)
## 执行结果为3
3.bit_length()方法
age1 = 5 //5的二进制表示为101
age2 = 10 //10的二进制表示为1010
r1 = age1.bit_length() //该方法求出该数字至少可用几位二进制数表示
r2 = age2.bit_length()
print(r1,r2)
## 执行结果为3 4
4.n次方表示方法
a = 2 ** 3 # 表示2的三次方
print(a)
## 执行结果为8
二、字符串
1.字符串常用方法
test = "zhangyixing"
a = test.capitalize() #首字母大写
b = test.casefold() #首字母小写
c = test.center(20) #设置宽度并将内容居中20指总长度
d = test.center(20,"*") #后面的参数代表空白位填充即用一个字符进行填充
e1 = test.count('i') #表示该字符在test中出现的次数
e2 = test.count('i',5) #从第五个位置开始找该子序列出现的次数
f = test.endswith("n") #表示该字符串是否以“n”作为结尾
g1 = test.find('i') #找到该子序列在字符串中第一次出现的位置
g2 = test.find('in',5,8) #-1表示未找到，一共有0~8个位置，该方法区间为左闭右开
g3 = test.find('in',5,9) #当位置处于9时，第八个位置就在该方法的有效区间内
2.format()方法
test2 = "I am {name}, age {a}"
h1 = test2.format(name='zhangyixing', a=29) # 格式化，将一个字符串中的占位符替换为指定的值
test2_1 = "I am {0}, age {1}"
h2 = test2_1.format('zhangyixing', 29) # 按0、1的顺序替换值
h3 = test2.format_map({"name": 'alex', "a": 29}) # 用{ }找到test中并替换name为alex...
print(test2) # I am {name}, age {a}
print(h1) # I am zhangyixing, age 29
print(h2) # I am zhangyixing, age 29
print(h3) # I am alex, age 29
3.索引、切片
# 索引
test = “zhangyixing”
v1 = test[1]
print(v1) # h
# 切片
v2 = test[0:1] # 结果为z （0<=x<1）
v2 = test[0:-1] # 结果为zhangyixin（直接到最后一个位置）
print(v2) # h
三、列表
# 列表有两种定义方式
li = ['alex', 'seven', 'eric']
li ＝ list(['alex', 'seven', 'eric'])
# 列表中的元素可以是数字、字符串、子列表、布尔值
li = [1, 2, 3, "age", "alex", [1, ["zhai", 21], 120], True]
列表常用操作有：append/extend/insert方法、索引、切片、循环等。
# 索引取值
print(li[4])
# 切片取值得到的结果也是个列表
print(li[3:5])
## 结果为['age', 'alex']
# 支持for循环和while循环
for item in li:
print(item)
# 列表元素可以被修改，如删除
del li[0]
print(li)
# 支持in操作
v = "age" in li
print(v) # 如果存在就输出true
将列表中的元素拼接起来有很多种情况：a.元素中包含多种类型；b.元素全是字符串；c.元素全是数字。
# a.列表中既有字符串又有数字
s = ""
for index in li:
s = s + str(index) # for循环内强转成str再拼接
print(s)
## 结果为23agealex[1, ['zhai', 21], 120]True
# b.列表中只有字符串
li = ["zhang", "yi", "xing", "1991"]
v = "".join(li) # ★用join拼接
print(v)
## 结果为zhangyixing1991
# ★append()函数
li = [11, 22, 33, 44]
li.append("zhai")
li.append(2000) # 直接接在li后面
print(li)
## 结果为[11, 22, 33, 44, 'zhai', 2000]
注：列表中的元素是有序的且可以被修改。
四、元组
元组是对列表的二次加工，一级元素不可被修改，不能被增加或者删除。
# 两种方式创建元组
ages1 = (11, 22, 33, 44, 55)
ages2 = tuple((11, 22, 33, 44, 55))
元组也可以索引取值和切片取值：
tu1 = (11, 22, 33, 44, True, (111, 222), ) # 最后加逗号和方法传参区分
print(tu1)
v1 = tu1[0] # 索引取值
v2 = tu1[0:2] # 切片取值
print(v1)
print(v2)
## 结果为11
## (11, 22)
# 取嵌套元素的值
tu2 = (1, 2, 3, "age", "alex", [1, ("zhang", 21), 120], True)
v = tu2[5][1][0]
print(v)
## 结果为zhang
元组的一级元素不可被修改：
# 一级元素不可被修改
tu2[3] = 10
print(tu2)
## 此时控制台会报错：TypeError: 'tuple' object does not support item assignment
# 嵌套的类型支持修改
tu2[5][1] = 1007 # 索引找的元素类型为列表，是支持修改的
print(tu2)
## 结果为(1, 2, 3, 'age', 'alex', [1, 1007, 120], True)
字符串、列表、元组之间可以相互转换：
s = "zifuchuan"
li = ["liebiao", 2000]
tu = ("yuanzu", 1998)
t1 = tuple(s) # 字符串可以转换成元组
print(t1)
t2 = list(s) # 字符串可以转换成列表
print(t2)
t3 = tuple(li) # 列表可以转成元组
print(t3)
t4 = str(li) # 列表可以转成字符串，形式不变，将一个列表作为一个字符串
print(t4)
t5 = list(tu) # 元组可以转换成列表
print(t5)
t6 = str(tu) # 元组可以转换成字符串，形式不变，将一个元组作为一个字符串
print(t6)
运行结果为：
【练习题】
【例1】有两个列表l1 = [11,22,33]和l2 = [22,33,44]，分别求a.获取内容相同的元素列表；b.获取 l1中有，l2中没有的元素列表；c.获取 l2中有，l1中没有的元素列表。
l1 = [11, 22, 33]
l2 = [22, 33, 44]
# a.获取内容相同的元素列表
for item1 in l1:
if item1 in l2:
print(item1)
# 结果为
# 22
# 33
# b.获取 l1中有，l2中没有的元素列表
for item2 in l1:
if item2 not in l2:
print(item2)
# 结果为11
# c.获取 l2中有，l1中没有的元素列表
for item3 in l2:
if item3 not in l1:
print(item3)
# 结果为44
【例2】有1、2、3、4、5、6、7、8这8个数字，能组成多少互不相同且无重复数字的两位数。
li_01 = ["1", "2", "3", "4", "5", "6", "7", "8"] # 新建操作繁琐
count1 = 0
for index1 in li_01:
for index2 in li_01:
if index1 != index2:
count1 = count1 + 1
print(count1)
# 结果为56
######## 以下为改进版 ########
count2 = 0
for i in range(1, 9): # 在for循环中直接用range(1, 9)创建1-8
for v in range(1, 9):
if i != v:
count2 += 1
print(count2)
# 结果为56
【例3】用while循环实现九九乘法表。
# 方式一：通过【for..in..】方法实现
for i in range(1, 10):
for j in range(1, i + 1):
print("%d*%d=%d" % (j, i, j * i), end=" ")
print("")
# 方式二：通过【while】方法实现
i = 1
while i < 10:
j = 1
while j <= i:
print("%d*%d=%d" % (j, i, j * i), end=' ')
j += 1
print("")
i += 1
运行结果为：
五、字典
# 两种方式创建字典dict
person1 = {"name": "mr.wu", 'age': 18}
person2 = dict({"name": "mr.wu", 'age': 18})
字典元素是无序的。
info = {"k1": "zhang",
2: True,
"k3": [11, 22, 33, {
"kk1": "vv1",
"kk2": "vv2"
}],
"k4": (111, 222, 333),
True: "yu" #列表、字典都不能作元组的key，但是元组、布尔值可以作为key
} # 键值对
print(info)
v1 = info["k1"] # 依据key取value
v2 = info[2]
v3 = info["k3"][3]["kk1"] # 索引取值
print(v1)
print(v2)
print(v3)
运行结果为：
字典是支持删除操作的。
del info["k4"] # 字典是支持删除的
print(info)
## 运行结果为{'k1': 'zhang', 2: True, 'k3': [11, 22, 33, {'kk1': 'vv1', 'kk2': 'vv2'}], True: 'yu'}
字典的for循环：
print("****第一种循环****")
for item in info:
print(item) # 默认循环key = for item in info.keys():
print("****第二种循环****")
for index in info.keys(): # 手动操作
print(index, info[index])
print("****第三种循环****")
for k, v in info.items(): # 与上述操作相同，常用！！
print(k, v)
运行结果为：
字典的常用方法：
1.fromkeys()
# 静态方法只需要用类.()
v1 = dict.fromkeys(["zhai", "yu", "xin"],1007)
print(v1)
## 结果为{'zhai': 1007, 'yu': 1007, 'xin': 1007}
2.get()
dic = {
"key01": "value01"
}
v2 = dic.get("key02", 2000) # 当没有key02的key值时，默认返回2000
print(v2)
## 结果为2000
3.setdefault()
v3 = dic.setdefault("key02", 'value02')
print(dic) # 当dict中没有的就赋值，有的就不赋值并返回已有的值
## {'key01': 'value01', 'key02': 'value02'}
4.update()
dic.update(k1=123, k2=345) # 自动转成字典
print(dic)
## {'key01': 'value01', 'key02': 'value02', 'k1': 123, 'k2': 345}
5.keys()和items()
# keys()
v4 = dic.keys()
print(v4)
## dict_keys(['key01', 'key02', 'k1', 'k2'])
# items()
v5 = dic.items()
print(v5)
## dict_items([('key01', 'value01'), ('key02', 'value02'), ('k1', 123), ('k2', 345)])
6.in操作
v6 = "value01" in dic.values()
print(v6)
# True
六、布尔值
# 0 1
# bool(...)
# None： "" () [] {} 0 ——>False 空字符串、空元组、空列表、0
【练习题】
【例1】元素分类：有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于等于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。即： {‘k1’: 大于等于66的所有值, ‘k2’: 小于66的所有值}。
li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
item1 = [] # 设置为空列表
item2 = []
for index in li:
if index >= 66:
item1.append(index)
else:
item2.append(index)
dic = {
'k1': item1, # 直接用名字替代
'k2': item2
}
print(dic)
## 运行结果为{'k1': [66, 77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}
【例2】查找：查找列表中元素，移除每个元素的空格，并查找以 a或A开头 并且以 c 结尾的所有元素。li = [“alec”, " aric", “Alex”, “Tony”, “rain”]，tu = (“alec”, " aric", “Alex”, “Tony”, “rain”)，dic = {‘k1’: “alex”, ‘k2’: ’ aric’, “k3”: “Alex”, “k4”: “Tony”}。
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' Aric', "k3": "Alex", "k4": "Tony"}
for a in range(len(li)): # 移除所有list元素中地空格
li[a] = li[a].replace(" ", "")
tu = list(tu) # 元组的一级元素不可被修改，转成list类型
for b in range(len(tu)):
tu[b] = tu[b].replace(" ", "")
tu = tuple(tu) # 输出形式将类型转变为原来的元组类型
for c in dic: # 删除字典元素中的空格
dic[c] = dic[c].replace(" ", "")
for a1 in li: # 查找以 a或A开头 并且以 c 结尾的list中的元素
if (a1.startswith("a") or a1.startswith("A")) and a1.endswith("c"):
print(a1)
for b1 in tu: # 查找以 a或A开头 并且以 c 结尾的tuple中的元素
if (b1.startswith("a") or b1.startswith("A")) and b1.endswith("c"):
print(b1)
for c1 in dic: # 查找以 a或A开头 并且以 c 结尾的dict中的元素
c2 = dic[c1].strip()
if (c2.startswith("a") or c2.startswith("A")) and c2.endswith("c"):
print(c2)
## 运行结果为
## alec
## aric
## alec
## aric
## Aric
【例3】打印输出商品列表，用户根据商品信息输入序号，页面显示用户选中的商品，li = [“手机”, “电脑”, ‘鼠标垫’, ‘游艇’]。
li = ["手机", "电脑", '鼠标垫', '游艇']
for key, i in enumerate(li, 0): # 为可迭代的对象添加序号★
print(key, i)
user = int(input("请输入商品序号:"))
print(li[user])
运行结果为：
【例4】功能要求：①要求用户输入总资产，例如：2000；②显示商品列表：让用户根据序号选择商品，加入购物车；③购买：如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998},
]
具体代码为：
# 购物车
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 100}
]
count = 0 # 用户账户金额
buymoney = 0 # 购物车商品金额
shopcar = [] # 购物车商品信息
def Shopping():
inputnum = input("--------------------\n请选择操作：\n1、查看资产\n2、查看商品\n3、查看购物车\n4、购买\n--------------------")
if inputnum == "1":
MyCount()
elif inputnum == "2":
Goods()
elif inputnum == "3":
ShopCar()
elif inputnum == "4":
pay()
else:
print("无此操作！")
Shopping()
def MyCount():
print("账户余额：" + str(count)) # 用字符串拼接的方式显示余额
inputop = input("--------------------\n请选择操作：\n1、返回\n2、退出\n")
if inputop == "1":
Shopping()
if inputop == "2":
quit()
else:
print("无此操作！")
MyCount()
def Goods():
global buymoney # 注意在方法中要使用全局变量时，加global，否则是无用功
global shopcar
for i in range(len(goods)):
print(str(i + 1) + "、商品名称：" + goods[i]["name"] + " " + str(goods[i]["price"]) + "元")
inputop = input("(输入选择序号加入购物车)\n其他操作：\no、查看购物车\nq、退出\nr、返回\n--------------------")
if inputop == "1":
shopcar.append(goods[0]) # 用append方法将用户选择的商品添加到购物车数组中
print("已将【" + goods[int(inputop) - 1]["name"] + "】加入购物车\n--------------------")
buymoney = buymoney + goods[int(inputop) - 1]["price"] # 购物车商品的总金额
elif inputop == "2":
shopcar.append(goods[1])
print("已将" + goods[int(inputop) - 1]["name"] + "加入购物车\n--------------------")
buymoney = buymoney + goods[int(inputop) - 1]["price"]
elif inputop == "3":
shopcar.append(goods[2])
print("已将" + goods[int(inputop) - 1]["name"] + "加入购物车\n--------------------")
buymoney = buymoney + goods[int(inputop) - 1]["price"]
elif inputop == "4":
shopcar.append(goods[3])
print("已将" + goods[int(inputop) - 1]["name"] + "加入购物车\n--------------------")
buymoney = buymoney + goods[int(inputop) - 1]["price"]
elif inputop == "o":
ShopCar()
elif inputop == "q":
exit()
elif inputop == "r":
Shopping()
else:
print("无此操作！")
Goods()
def ShopCar():
if len(shopcar) == 0:
print("购物车为空")
for item in shopcar:
print(item["name"] + " " + str(item["price"])) # 购物车不为空时，循环输出购物车中的商品
def pay():
global count
global buymoney
if buymoney < count:
count = count - buymoney
print("您已经成功购买！")
print("账户余额为：" + str(count))
shopcar.clear() # 用户成功购买后清空购物车
else:
print("账户余额不足！")
count = int(input("请输入您的总资产："))
Shopping()
七、集合
集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
# 第一种方式创建集合
parame = {value01,value02,...}
# 第二种方式创建集合
s = set(['alex', 'alex', 'zhai'])
## 输出为{'zhai', 'alex'}，无重复元素且元素无序
集合的内置方法：
两个集合间的多种运算：
# 下面展示两个集合间的运算.
a = set('abracadabra')
b = set('alacazam')
print("集合a：", a)
print("集合b：", b)
# 差集
print("集合a中包含而集合b中不包含的元素:")
print(a - b) # 等价于print(a.difference(b))
# 并集
print("集合a或b中包含的所有元素:")
print(a | b) # 等价于print(a.union(b))
# 交集
print("集合a和b中都包含了的元素:")
print(a & b) # 等价于print(a.intersection(b))
# 交叉补集
print("不同时包含于a和b的元素")
print(a ^ b) # 等价于print(a.symmetric_difference(b))
运行结果为：
部分方法实例：
1.add()
s = {1, 2, 3, 4, 5, 6}
s.add('zhai')
## 结果为{1, 2, 3, 4, 5, 6, 'zhai'}
# 还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式为s.update( x )
2.clear()
s = {1, 2, 3, 4, 5, 6}
s.clear()
print(s)
## 结果为set()
3.copy()
s = {1, 2, 3, 4, 5, 6}
s1 = s.copy()
print(s1)
## 结果为{1, 2, 3, 4, 5, 6}
4.pop()
s = {1, 2, 3, 4, 5, 6, 'zhang', 'yi', 'xing'}
s.pop()
print(s)
## 结果为{2, 3, 4, 5, 6, 'xing', 'yi', 'zhang'} 随意删除了一个元素
5.remove()
# 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。s.remove( x )
s = {1, 2, 3, 4, 5, 6, 'zhang', 'yi', 'xing'}
s.remove('zhang')
print(s)
## 结果为{1, 2, 3, 4, 5, 6, 'xing', 'yi'}
【补充知识】字符串格式化
1、百分号方式
①打印字符串和数字
str1 = 'I am %s ,my age is 21' % 'zhang'
print(str1)
str2 = 'I am %s,my hobby is %s,my age is %d' % ('zhang', 'reading', 21)
print(str2)
## 结果为I am zhang ,my age is 21
## I am zhang,my hobby is reading,my age is 21
②打印float类
v1 = "percent %f" % 99.9999
print(v1) # 默认保留小数点后6位
## 结果为percent 99.999900
# 仅保留两位小数
v2 = "percent %.2f" % 99.987654
print(v2)
## 结果为percent 99.99(四舍五入)
③打印百分比
v = "percent %.2f %%" % 99.9824
print(v)
## 结果为percent 99.98 %
④打印字典类型
tp = 'I am %(name)s, My age is %(age)d.' % {"name": "zhang", "age": 18}
print(tp)
## 结果为I am zhang, My age is 18.
2、Format方式
%[(name)][flags][width].[precision]typecode
tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
tp2 = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
tp3 = "i am {0}, age {1}, really {0}".format("seven", 18)
tp4 = "i am {0}, age {1}, really {0}".format(*["seven", 18]) # *代表传入的是一个列表
tp5 = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
tp6 = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
tp7 = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
tp8 = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tp9 = "i am {:s}, age {:d}".format(*["seven", 18]) # 第一个位置取字符串，第二个位置取数字
tp_l0 = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tp_l1 = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18}) # *代表传入的是一个字典
tp_l2 = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2) # :b代表转换为二进制，:o代表转换为八进制，:x代表十六进制小写，:X代表十六进制大写，:%转换为百分比
tp_l3 = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tp_l4 = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
tp_l5 = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
运行结果为：
