一、基本数据类型
1.1、数字
int（整型）
在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807
1.2、布尔值
true\false 或者 1\0
1.3、字符串
| 方法 | 说明 |
|---|---|
| capitalize() | 首字母大写 |
| center(width, fillchar=None) | 设置总宽度width然后将内容居中,两侧用fillchar填充.注意填充的内容只能用单个字符,而且可以忽略,默认为空格 |
| ljust(width, fillchar=None) | 和center类似,是从左边开始对齐然后填充 |
| rjust(width, fillchar=None) | 和center类似,是从右边开始对齐然后填充 |
| count(sub,start=None,end = None) | 在字符串内计算sub出现的次数,支持字符和子序列,可以指定开始和结尾,也可以不指定 |
| encode(编码方式) 与 decode(编码方式) | 这个涉及到编码,后边在字节模式操作文件的时候,可以将要写入的内容进行编码来写入,或者将读取的内容按照某种方式解码. |
| expandtabs(tabsize=8) | 用指定的长度来把\t制表符变成空格,默认是8 |
| endswith(suffix,start=None,end =None) | 返回布尔类型,判断字符串是否以suffix对应的字符串结尾.suffix还可以是一个字符串元组.当是元组的时候,元组的元素只要满足至少有一个满足条件,就返回True,全都不满足,返回False. |
| startswith(prefix, start=None, end=None) | 返回布尔类型,判断字符串是否以suffix对应的字符串开头.suffix还可以是一个字符串元组.当是元组的时候,元组的元素只要满足至少有一个满足条件,就返回True,全都不满足,返回False. |
| find(sub,start=None,end =None | 在字符串内从前往后寻找sub子序列,返回找到的第一个索引.如果没找到,返回-1.注意,用的索引都是左闭右开 |
| rfind(sub, start=None, end=None) | find从右边开始的版本 |
| format(*args, **kwargs) | 这是python 字符串的格式化内容,将字符串中的占位符替换为指定的值.format的用法需要单独学习 |
| format_map(dict) | 用字典的方式来给出参数,dict的键是占位符的名称,值是要替换的内容 |
| index(obj) | 用法和find一样,但是index找不到的时候会报错,而不是像find一样返回-1 |
| rindex(sub, start=None, end=None) | 这是从右边开始的index,用法和find一样,但是index找不到的时候会报错,而不是像find一样返回-1 |
| isalnum() | 判断这个字符串是不是只由数字和字母组成 |
| isalpha() | 判断字符串是否只由字母组成,而且至少有一个字母 |
| isdecimal() | 判断这个字符串是不是只由十进制数字构成,而且至少有一个数字 |
| isdigit() | 判断这个字符串是否由包括十进制以及特殊的数字字符组成 |
| isnumeric() | 这个下边有解释,这个支持的最全,包括汉字的数字也可以识别.关于isdecimal,isdigit和isnumeric的区别在下边 |
| isidentifier() | 这个是指字符串是否符合python标识符,即由数字字母和下划线组成,而且不能以数字开头 |
| islower() | 判断是否全部为小写 |
| isprintable() | 这个是指是否只包含可以打印的字符,ASCII里的控制符都是不可打印字符 |
| isspace() | 所有字符是否都是空格 |
| istitle() | 所有字符是否符合首字母大写剩下字母小写,就是像英文的标题一样的格式 |
| isupper() | 所有字母是否都是大写 |
| **join(*args, kwargs) | 这是非常重要的一个方法,是分隔符.join(分割对象),而且很多其他数据类型也支持join方法 |
| lower() | 将字符串全部变成小写 |
| upper() | 将字符串全部变成大写 |
| maketrans(*args, **kwargs) | 这个要和translate一起讲,maketrans建立一个替换映射规则,然后用translate替换字符串.用的时候要调用str类该函数 |
| translate(table) | 用建立的映射关系table来替换字符串,用法示例看这里 |
| lstrip(string) | strip系列是去掉匹配的字符,默认是去掉空格,有lstrip,rstrip和strip,分别是从左边,从右边,从两边去掉.如果给出字符串参数,则会按照对象和参数的最长共同子序列不断匹配去掉,直到无法匹配为止. |
| rstrip(string) | 属于strip系列 |
| strip(string) | 属于strip系列,strip系列在清洗字符串数据,获取用户输入等方面经常使用 |
| partition(sep) | 用sep分割字符串,只按照找到的第一个进行分割,分割成包含三部分的一个元组,sep是第二个元素,如果找不到sep,则分割出来的元组的后两项为空 |
| rpartition(sep) | partition从右边开始的版本 |
| replace(old, new, count=None) | 用new替换old,不指定次数则默认全部替换,否则替换count次 |
| rsplit(sep=None, maxsplit=-1) | 这是属于split系列,用sep分割,但是sep不再取回,默认全部分割,也可以指定分割次数 |
| split(sep=None, maxsplit=-1) | split系列,split是没有lspilt的,默认就是从左边开始 |
| splitlines(keepends=None) | 按照换行符\n来分割字符串,如果参数为True则每个分割的末尾会保留\n |
| swapcase() | 切换字符串里的大小写,大写变小写,小写变大写 |
| title() | 格式化成英文标题一样的格式,每个单词的首字母大写,其他字母变成小写. |
cap = "hello world"
print(cap.capitalize()) # Hello world
print(cap.center(50)) # 居中，左右填空白
print(cap.count("l")) # 统计l出现的次数 3
print(cap.endswith("rld")) # 判断结尾是否满足条件 True
print(cap.startswith("wor")) # 判断起始是否满足条件 False
print(cap.find("l")) # 返回找到的第1个索引值 2， 注意下标都是从0开始
name ="helloworld"
str_num = "hello123world"
print(str_num.isalnum()) # 如果有空格就是false
print(str_num.isalpha()) # False
print(name.isalpha()) # True， 有空格也是false
print(name.isidentifier()) # 判断这个标识是否满足python要求 xx_xx
print(name.islower()) # 判断是否全是小写
print(name.upper().isupper()) # 改成大小，这里就是true了
print(name.replace("world", "xiong")) # helloxiong
# isnumeric isdecimal isdigit 三种比较
num = "1"
print(num.isnumeric()) # True
print(num.isdecimal()) # True
print(num.isdigit()) # True
num = b"1" # 二进制
# print(num.isnumeric()) # AttributeError: 'bytes' object has no attribute 'isnumeric'
# print(num.isdecimal()) # AttributeError: 'bytes' object has no attribute 'isnumeric'
print(num.isdigit()) # True
num = "IV" # 罗马
print(num.isnumeric()) # False
print(num.isdecimal()) # False
print(num.isdigit()) # False
num = "四"
print(num.isnumeric()) # True
print(num.isdecimal()) # False
print(num.isdigit()) # False
# ===========================================================================
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False: 汉字数字
Error: 无
isdecimal()
True: Unicode数字，，全角数字（双字节）
False: 罗马数字，汉字数字
Error: byte数字（单字节）
isnumeric()
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
False: 无
Error: byte数字（单字节）
# ===========================================================================
# 将列表直接变为字符串
xxx = [1, 22, 3, 4]
x = "".join(str(i) for i in xxx)
print(x) # 12234
1.4、列表
| 方法 | 说明 |
|---|---|
| append(p_object) | 列表尾部追加一个元素.修改对象.返回None. |
| clear() | 删除列表里的所有元素,返回空列表,直接修改对象,返回None. |
| copy() | 赋给一个新变量则得到当前列表的复制,是一个新列表,引用和原来的列表不同.注意这个方法得到的是 浅拷贝 |
| count(value) | 返回value在列表元素中出现的整型次数,不修改原列表 |
| extend(iterable) | 将一个可迭代对象iterable里的元素增加到列表里.例如b.extend(range(10,21)),本身返回None |
| index(value, start=None, stop=None) | 查找值返回索引整型,如果没有会报ValueError |
| insert(index, p_object) | 在指定的索引位置插入元素,该索引位置上的原来元素及后边元素向后移动 |
| pop(index=None) | 弹出某一个索引的元素,返回这个元素,同时将这个元素从原列表里删除,如果不指定索引,则默认弹出最后一个.如果列表为空则报IndexError |
| remove(value) | 从列表里去掉查到到的第一个value,如果找不到value,会报ValueError.如果成功去除,返回None.Python删除列表内的元素还可以用del li[index]或者del 切片的方法 |
| reverse() | 就地倒转列表顺序,直接修改原列表 |
| sort(key=None, reverse=False) | 就地排序,直接修改原列表,key可以用一个函数或者lambda表达式来做判断,reverse默认是升序,如果是True则降序.内置函数有一个sorted()函数也可以用来排序,但是sorted函数不会修改原列表 |
# 通过列表生成式，生成 h1到h9
li = ["h{}".format(i) for i in range(1, 10)]
li.append("h10") # 如果直接打印会返回None
li.clear() # 清空列表中所有
n_li = li.copy() # 得到的是浅拷贝
print(li.count("h3")) # 返回列表中h1出现的次数
li2 = ["x1","x2"]
print(li.extend(li2)) # 将li2添加到li中，最后追加
li.insert(5,"h66") # 在第5个索引位置添加，注意下标是从0开始
print(li.pop()) # 不指定下标就是从最后开始删除
print(li.pop(5)) # 将第5个索引位置的值删除
print(li.remove("h3")) # 删除列表中的h3
print(li.remove("h33")) # 如果h33不存在，则会返回 ValueError
print(li.reverse()) # 倒转列表
li2 = [2, 3, 1, 5, 77, 6, 9, 10, 99]
li2.sort() # 升序 从小到大
li2.sort(reverse=True) # 降序， 从大到小
直接赋值 浅拷贝 深拷贝
- 直接赋值：其实就是对象的引用（别名）。
-
浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象，在内存中只额外创建第一层数据
-
深拷贝(deepcopy)：如果需要深拷贝,导入copy模块的deepcopy方法，完全拷贝了父对象及其子对象。在内存中将所有的数据重新创建一份，
copy.deepcopy(xx)
1.5、元组
元组其实是对列表的二次加工,主要的区别就是元素不可被修改,也不能增加或者删除元素.
用tuple()来生成元组,tuple(iterable)将迭代器的内容拿到一个元组里.
注意,写元组的时候,一般要在最后一个元组后边加一个逗号,就可以很清楚的看到是元组.这是惯例.
扫描二维码关注公众号，回复：
12429647 查看本文章
| 方法 | 说明 |
|---|---|
| count(self, value) | count方法,返回次数 |
| index(value, start=None, stop=None) | 查找值返回索引整型,如果没有会报ValueError |
tr = ("t1", "t2",)
print(tr.count('t1')) # 统计 t1出现的次数 1
print(tr.index("t1")) # 查找 t1的下标 0
print(type(tr)) # <class 'tuple'>
1.6、字典
字典就是python语言的哈希表，拥有键值对，键key必须是一个可以hash的值，所以列表不能够作为key,字典也不能够作为key,因为这二者都会产生变化.值则没有限制,可以是任何对象，字典是无序的,字典值的索引就是键.
| 方法 | 说明 |
|---|---|
| clear() | 返回None,清除整个字典 |
| copy() | 复制字典,注意这个也是浅复制 |
| fromkeys(*args, **kwargs) | 这个因为有@staticmethod,这是一个静态方法,也就是通过类名调用的方法,这个方法的内容是用给定的克迭代对象和对应的值来产生一个字典,在下边有示例 |
| get(k, d=None) | 字典可以直接用key来获得值,但是如果key不存在的话会报错.这时候可以用get方法来取得k对应的值,如果键中没有k,则会返回d,d默认是None,可以自行指定.get函数通常用在结合键值是否在字典内和需要返回一个特殊东西时候的场合 |
| items() | 返回这个字典里所有的键值对,类似一个集合.很python的写法就是用两个变量来同时接收键和值 |
| keys() | 返回字典里的所有的key构成的一个类似集合的对象,对迭代器的操作都可以用在返回对象上 |
| pop(k, d=None) | 按照键k对应的值从字典里弹出.如果找不到k,则返回d,如果d没有指定,则返回KeyError |
| setdefault(k, d=None) | 将字典里k的值设置为d.但是如果k已经存在,则不做任何修改.两种情况都返回k对应的值. |
| update(E=None, **F) | 更新列表,返回None.更新的机制是可以用k=v来当参数,也可以传一个字典,如果键已经存在,则更新值,否则将键值对更新到字典内. |
| values() | 返回字典里所有值构成的一个类似于元组的东西.可以使用迭代器操作. |
d = {
"dk1": "v1", "dk2": "v2"}
# d.clear() # 清空字典
d2 = d.copy()
d["dk3"] = "v3"
print(d.get("dk3")) # v3
print(d["dk3"]) # v3
print(d.keys()) # dict_keys(['dk1', 'dk2', 'dk3'])
print(d.values()) # dict_values(['v1', 'v2', 'v3'])
d.setdefault("dk4", "d333") # 如果值存在不修改，不存在则添加
d.update(dk5="v5") # 不存在则直接添加
d.update(dk4="v4") # 存在，则会直接修改值
d["dk4"] = "vv4" # 与 d.update(dk4="v4") 相等,不存在 则添加
print(d)
练习
一、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {
'k1': 大于66的所有值, 'k2': 小于66的所有值}
二、查找
查找列表中元素，移除每个元素的空格，并查找以 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 = ["手机", "电脑", '鼠标垫', '游艇']
四、购物车
功能要求：
要求用户输入总资产，例如：2000
显示商品列表，让用户根据序号选择商品，加入购物车
购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
附加：可充值、某商品移除购物车
goods = [
{
"name": "电脑", "price": 1999},
{
"name": "鼠标", "price": 10},
{
"name": "游艇", "price": 20},
{
"name": "美女", "price": 998},
]
五、用户交互，显示省市县三级联动的选择
dic = {
"河北": {
"石家庄": ["鹿泉", "藁城", "元氏"],
"邯郸": ["永年", "涉县", "磁县"],
}
"河南": {
...
}
"山西": {
...
}
}
# 答案
# 一、元素分类
li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
new_k = {
"k1": None, "k2": None}
new_k["k1"] = [i for i in li if i >= 66]
new_k["k2"] = [i for i in li if i <= 65]
print(new_k) # {'k1': [66, 77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}
# ------- 写法二
x1, x2 = [], []
for i in li:
x1.append(i) if i >= 66 else x2.append(i)
new_k["k1"] = x1
new_k["k2"] = x2
print(new_k) # {'k1': [66, 77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}
# 最粗暴写法
new_k = {
"k1": [i for i in li if i >= 66], "k2": [i for i in li if i <= 65]}
print(new_k) # {'k1': [66, 77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}
# 查找列表中元素，移除每个元素的空格，并查找以 x或X开头 并且以 g 结尾的所有元素。
li = ["gg", " xiong", "Hei", "Tony", "sum"]
for s in li:
if s.split()[0].lower().startswith("x"):
if s.endswith("g"):
print(s)
# 三、输出商品列表，用户输入序号，显示用户选中的商品
li = ["手机", "电脑", '鼠标垫', '游艇']
while True:
for l in enumerate(li, 0): print(l)
chiose = int(input("请输入选项： ").strip())
if chiose >= len(li):
print("超出选项")
continue
print("您的选择是: {}".format(li[chiose]))
break
# 四、购物车
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
goods = [
{
"name": "电脑", "price": 1999},
{
"name": "鼠标", "price": 10},
{
"name": "游艇", "price": 20},
{
"name": "美女", "price": 998},
]
buy = []
# 帐户金额，购物车金额
count_asset = 0
while True:
print("1、购买商品\n2、结账\n3、充值\n4、移除购物车\n")
chiose = input("请输入选项: ")
if chiose in ["1", "2", "3", "4"]:
if chiose == "1":
while True:
print("商品列表--------> ")
for kindex, key in enumerate(goods): print(kindex, key["name"])
try:
buy_chiose = int(input("请输入要购买的物品序号 (任意键退出购买): "))
if buy_chiose >= len(goods):
print("没有这个商品，退出购买")
break
except:
print("退出购买")
break
buy.append(goods[buy_chiose])
print("当前购买的商品有 {}".format([buys["name"] for buys in buy]))
elif chiose == "2":
buy_asset = 0
if buy:
price = [buys["price"] for buys in buy]
for i in price: buy_asset += i
if buy_asset <= count_asset:
print("购买成功, 商品列表: {}, 剩余金额: {}".format([buys["name"] for buys in buy], count_asset - buy_asset))
buy.clear()
else:
print("金额不足以付款, 请充值或删除商品，当前商品金额: {}".format(buy_asset))
else:
print("没商品，请先去购买")
elif chiose == "3":
asset = int(input("充值的金额: ").strip())
count_asset += asset
print("当前金额： {}".format(count_asset))
elif chiose == "4":
print("移除商品")
else:
print("输入错误")
continue
1.7、集合
set集合，是一个无序且不重复的元素集合，由不同的元素组成,即集合内不能有重复的元素.集合内的元素是无序排列,而且是可哈希的值,也就是不可变类型.这些元素也可以作为字典的key， 集合的定义,用大括号{}
直接定义集合用大括号 set_a = {1,2,3,4,5} 集合在生成的过程中会自动去除重复元素.集合无序所以也不支持索引，还可以采用set函数生成集合,如果是列表或者元组,会将其中每个元素拆开,如果是字符串,会将每个字符拆开.
set函数如果对字典使用,只会生成包含键的集合,对列表使用,则列表的元素不能有不可哈希的元素.
| 方法 | 说明 |
|---|---|
| add(item) | 向集合内增加一个元素,add只接受一个参数 |
| clear() | 清空集合 |
| copy() | 这个也是浅复制 |
| pop() | 弹出集合中的一个元素,如果集合为空,返回KeyError.这个是随机删除. |
| remove(item) | 指定删除,参数必须是集合内的元素,如果不存在,返回KeyError |
| discard(item) | 指定删除,参数必须是集合内的元素,如果不存在,不做任何事情,也不报错.返回None |
set_a = {
1, 2, 4, 1, 2, 3, 6, 7, 8, 9}
set_a.add("abc") # 最后添加一个abc
# set_a.clear() # 清空集合的所有值， 返回set_a()
# set_b = set_a.copy() # 浅拷贝
# print(set_b)
set_a.pop() # 随机删除一个
set_a.remove("abc") # 只能删除存在的否则报 KeyError
set_a.discard("333") # 不存在也不会报错，存在就删除
print(set_a)
7.1、集合的逻辑关系运算
集合的逻辑运算符有:
in not in
== != <,<=
>,>= |,|= 合集 &,&= 交集
-,-= 差集 ^,^=交叉补集
7.2、集合方法
| 方法 | 说明 |
|---|---|
| intersection(anotherset) | 求自身和另外一个集合anotherset的交集,符号是& |
| union(anotherset) | 求自身和另外一个集合的并集,符号是| |
| difference(anotherset) | 求差集,存在于原集合但不存在参数集合的结果.注意差集交换集合的顺序,结果是不同的.符号是- |
| symmetric_difference(anotherset) | 交叉补集,首先把两者合并到一起,然后减去两者共有的部分,相当于并集-交集.符号是^ |
| difference_update(anotherset) | 把属于anotherset里的元素直接从当前集合中去掉.这些带有update的方法都是直接更新调用方法的集合.那些不带update的方法,如果要接受更改之后的集合,需要用另外一个参数去接收,或者用|=这种符号. |
| intersection_update(anotherset) | 取交集,然后赋给调用方法的变量,即操作完毕之后,原集合变为交集. |
| isdisjoint(s) | 如果两个集合没有交集,返回True,否则返回False |
| issubset(s) | 如果s包含当前集合,则返回True,否则返回False.就是看当前集合是否是s的子集,相当于<= |
| issuperset(s) | 如果s是当前集合的子集,返回True,否则返回False.相当于>= |
| symmetric_difference_update(s) | update系列方法 |
| update(s) | 单独的update方法就是用并集更新调用方法的集合.没有union_update方法.另外update可以传可迭代对象,可以将可迭代对象拆解后更新多个值进当前集合.而add只能添加一个值,给add传可迭代对象,会将可迭代对象作为单个元素传进去. |
二、标准数据类型特性总结
1.1、按存值个数区分
标量／原子类型 数字，字符串
容器类型 列表，元组，字典
1.2、按可变不可变区分
# 可变类型： 列表，字典
# 不可变类型：字符串，元组，数字，集合
1.3、按访问顺序区分
直接访问 数字
顺序访问（序列类型） 字符串，列表，元组
key值访问（映射类型） 字典
1.4、数据类型转换内置函数汇总
aa = 97
print(chr(aa)) # a
print(ord("a")) # 97
print(hex(aa)) # 0x61
print(oct(aa)) # 0o141
三、格式化字符串
3.1、%
# 语法
%[(name)][flags][width].[precision]typecode
name一定要加一个括号,相当于变量名.
flags 可选，可供选择的值有:
+ 右对齐；正数前加正好，负数前加负号；
– 左对齐；正数前无符号，负数前加负号；
空格 右对齐；正数前加空格，负数前加负号；
0 右对齐；正数前无符号，负数前加负号；用0填充空白处
width表示宽度,是一个正整数,表示用多少宽度来显示,如果宽度小于要显示的内容长度,则无效.
.precision 是保留多少位数或者取多少位数
typecode是必须的,表示以何种类型显示,常用的是s字符串,d十进制
name = "xiong"
age = 111
print("姓名 %s %d" %(name, age)) # 姓名 xiong 111
%s: 字符串格式
%d: 整形
%f: 浮点形 # 只取两位小数点 %.02f
str_num = 0.22222
print("比例 %.02f%%" % (str_num * 100))
# 输出学号为 000001
stu_num = 1
print("学号为: %06d" % (stu_num)) # 000001
# %s 中间加 - 代表靠左打印 -50 表示总共50个,以空格代替
# end="" 不换行， 行首显示
# print("[%-50s]" %("#") ) # [# ]
# 动态调整
# res = "[%%-%ds]" % 50
# print(res %("#"))
# print(res %("##"))
import time
# 往左靠齐，下一行将上一行直接覆盖
print(("\r[%%-%ds]" %50) %"#", end="")
time.sleep(0.5)
print(("\r[%%-%ds]" %50) %"##", end="")
time.sleep(0.5)
print(("\r[%%-%ds]" %50) %"###", end="")
3.2、format
推荐使用这种
如果要加格式,则要用 索引:操作符的方式,操作符的方式就是:
{
name:[[fill]align][sign][#][0][width][,][.precision][type]}
举例:
以50的宽度显示,空白填充!: {
name:!^50s}
align 【可选】对齐方式（需配合width使用）
<，内容左对齐 >，内容右对齐(默认)
＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
^，内容居中
sign 【可选】有无符号数字
+，正号加正，负号加负；
-，正号不变，负号加负；
空格 ，正号空格，负号加负；
print("my name {0} age {1}".format(name, age))
# 40个浮点， 以! 填充空白
print("比例 {:!^40f}".format(str_num)) # 比例 !!!!!!!!!!!!!!!!0.222220!!!!!!!!!!!!!!!!
# 只保留 2 位小数点的浮点数
print("比例 {: ,.2f}".format(str_num)) # 比例 0.22
# 填充40个空白字符串
print("比例 {: <40,.2f}".format(str_num)) # 比例 0.22 （这边还有一堆空白字符串）