int ==> 整数. 主要?来进?数学运算
str ==> 字符串, 可以保存少量数据并进?相应的操作
bool==>判断真假, True, False
list==> 存储?量数据.?[ ]表?
tuple=> 元组, 不可以发?改变 ?( )表?
dict==> 字典, 保存键值对, ?样可以保存?量数据
set==> 集合, 保存?量数据. 不可以重复. 其实就是不保存value的dict
在Python 3 中所有的整数都是int类型,但在Python 2 中如果数据量较大则会采用 long类型,而在Python 3 中没有long类型。
常用方法:
? 1、bit_length():计算整数在计算机中占用的二进制数的长度。
取值只有True和False。
转换问题:
字符串:把字符连成串. 在python中?‘, ", ‘‘‘, """引起来的内容被称为字符串.
索引和切片
索引:索引指的就是下标,索引从0开始。
切片:截取字符串指定部分的内容。
? 语法:str[起始位置,结束位置,步长]
? 规则:“顾头不顾尾”,即包含起始位置,但不包含结束位置。
? 步长:如果是整数,则从左往右取,如果是负数,则从右往左取,默认是1。
content = "生活不止眼前的苟且,以后还有一大堆的苟且。"
例:截取“眼前的苟且,以后还有”
print(content[4:14])
例:截取“生不眼的且以还一堆苟”
print(content[::2])
例:将内容翻转
print(content[::-1])
例:截取“一有还后以,且苟的前”
print(content[14:4:-1])
例:截取“止眼前的苟且,以后还有一大堆的苟且。”
print(content[3:])
字符串其它相关方法
注意:切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的。
字符串中的字母全部大写
content = “dogfa is a verv beautiful boy!”
content = content.upper()
print(content)
==>"DOGFA IS A VERV BEAUTIFUL BOY!"
字符串中的字母全部小写
content = “DOGFA IS A VERV BEAUTIFUL BOY!”
content = content.lower()
print(content)
==>"dogfa is a verv beautiful boy!"
英文首字母大写
content = “dogfa is a verv beautiful boy!”
content = content.capitalize()
print(content)
==>"Dogfa is a verv beautiful boy!"
大小写转换
content = “dOgfA iS A verv beautiful boy!”
content = content.swapcase()
print(content)
==>"DoGFa Is a VERV BEAUTIFUL BOY!"
每个被特殊字符隔开的单词首字母大写
content = "dogfa is a verv beautiful boy!"
content = content.title()
print(content)
==>"Dogfa Is A Verv Beautiful Boy!"
居中
content = "欢迎光临~"
content = content.center(15, "*") #将长度拉长为15,两边用‘*’填充
print(content)
==> "*****欢迎光临~*****"
清除空格
content = " 其实世上本没有路,走的人多了也就成了路 "
content = content.strip() #清楚两端空格
print(content)
==> "其实世上本没有路,走的人多了也就成了路"
str.lstrip() # 清除左端空格
str.rstrip() # 清楚右端空格
str.strip("明") # 清除左右两端的“明”
content = "明天到操场操到天明"
content = content.strip("明")
print(content)
==> "天到操场操到天"
字符串替换
content = "明天到操场操到天明"
content = content.replace("操", "*")
print(content)
==> "明天到*场*到天明"
str.replace("需要替换的字符串", "替换为的字符串", "替换数量") # 替换数量默认为全部替换
content = content.replace("操", "*", 1)
print(content)
==> "明天到*场操到天明"
字符串切割
content = "清明时节雨纷纷,路上行人欲断魂,借问酒家何处有,牧童遥指杏花村"
content = content.split(",")
print(content)
==> "['清明时节雨纷纷', '路上行人欲断魂', '借问酒家何处有', '牧童遥指杏花村']"
content = content.split("清")
print(content)
==> "['', '明时节雨纷纷,路上行人欲断魂,借问酒家何处有,牧童遥指杏花村']"
注意:如果切割点在开头或者结尾,都将会在列表的开头或结尾产生一个空字符串。
格式化输出
例:要求输入以下内容
*********Welcome~*********
name: dogfa
age: 80
job: piaoke
hobby: piaochang
**************************
我们可以这样:
info = '''*********Welcome~*********
name: {0}
age: {1}
job: {2}
hobby: {3}
**************************'''
name = "dogfa"
age = 80
job = "piaoke"
hobby = "piaochang"
print(info.format(name, age, job, hobby))
我们也可以这样:
info = '''*********Welcome~*********
name: {name}
age: {age}
job: {job}
hobby: {hobby}
**************************'''
name2 = "dogfa"
age2 = 80
job2 = "piaoke"
hobby2 = "piaochang"
print(info.format(name=name2, age=age2, job=job2, hobby=hobby2))
查找
content = "明天到操场操到天明"
content = content.find("操")
print(content)
==> 3(返回的是下标)
str.find("查找内容", "起始位置", "结束位置") # 切片查找
content = content.find("操", 4, 7)
print(content)
==> 5
注意:只能查找到第一个内容的索引,查找不到时将会返回"-1"。
str.index("查找内容")
content = content.index("操")
print(content)
==> 3
注意:查找不到内容时将会直接抛出异常。建议使用find()。
str.startswith("明") # 判断字符串是否以“明”开头
str.endswith("明") # 判断字符串是否以“明”结尾
content = content.startswith("明")
==> True
content = content.endswith("明")
==> True
条件判断
# 判断是否为纯数字
str.isdigit()
content = "123456"
content = content.isdigit()
print(content)
==> True
content = "123456abc"
content = content.isdigit()
print(content)
==> False
# 判断是否为纯英文
str.isalpha()
content = "abcde"
content = content.isalpha()
print(content)
==> True
content = "123456abc"
content = content.isalpha()
print(content)
==> False
# 判断是否由数字和字母组成
str.isalnum()
content = "abcde123456"
content = content.isalnum()
print(content)
==> True
content = "@123avb"
content = content.isalnum()
print(content)
==> False
# 其它
str.isdecimal()
str.isnumeric() # 这个可以判断中文
content = "壹仟伍佰"
content = content.isnumeric()
print(content)
==> True
计算字符串的长度
content = "你猜我有多长?"
print(len(content))
==> 7
注意:注意: len()是python的内置函数. 所以访问?式也不?样。
字符串的拼接
content = "嘿嘿嘿"
content = "_".join(content)
print(content) # 嘿_嘿_嘿
迭代
for "变量" in "可迭代对象":
pass
content = "喜欢唱跳rap篮球"
for item in content:
print(item)
==> 喜
欢
唱
跳
r
a
p
篮
球
可迭代对象:简单来说就是可以一个一个往外取值的对象,如str, list, tuple。
1、列表的介绍
列表:列表是Python的基础数据类型之? ,其他编程语?也有类似的数据类型. 比如JS中的数
组, java中的数组等等. 它是以[ ]括起来, 每个元素?‘ , ‘隔开?且可以存放各种数据类型:
例:
lst = ["嘿嘿", "吼吼", ["我是", "列表"], ("I'm", "tuple"), {"dict": "我是字典"}, {"set", "我是集合呀"}, 2]
列表相比于字符串可以存取更多类型的数据,而且可以存放大量的数据。列表是有序的,可以通过索引对列表进行切片取值等操作。
2、列表的索引和切片
列表和字符串一样拥有索引
lst = ["孙悟空", "猪八戒", "沙僧", "唐僧"]
print(lst[0]) # 孙悟空
print(lst[1]) # 猪八戒
print(lst[2]) # 沙僧
print(lst[3]) # 唐僧
lst[0] = "齐天大圣" # 注意:列表是可变类型,可以直接发生改变,和字符串不一样哈
print(lst) # ["齐天大圣", "猪八戒", "沙僧", "唐僧"]
temp = "天蓬元帅"
temp[0] = "地"
print(temp) # TypeError: 'str' object does not support item assignment (不可变类型)
列表的切片
lst = ["孙悟空", "猪八戒", "沙僧", "唐僧"]
print(lst[0:2]) # ["孙悟空", "猪八戒", "沙僧"]
print(lst[::2]) # ["孙悟空", "沙僧"]
print(lst[::-1]) # ['唐僧', '沙僧', '猪八戒', '孙悟空']
print(lst[-1:1:-1]) # ["唐僧", "沙僧"]
3、列表的增删该查
注意:列表是可变类型,所以可以直接对列表中的元素进行操作。
增
lst = ["name", "age", "job", "hobby"]
lst.append("gender")
print(lst) # ["name", "age", "job", "hobby", "gender"]
lst = ["name", "age", "job", "hobby"]
lst.insert(1, "gender")
print(lst) # ["name", "gneder", "age", "job", "hobby"] 按照索引进行插入
lst = ["name", "age", "job", "hobby"]
lst.extend(["gender", "salary"])
print(lst) # ["name", "age", "job", "hobby", "gender", "salary"] 将可迭代对象进行迭代添加
lst = ["name", "age", "job", "hobby"]
lst.extend("hello")
print(lst) # ['name', 'age', 'job', 'hobby', 'h', 'e', 'l', 'l', 'o']
删
lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
ret1 = lst.pop() # 默认删除列表最后一个元素,并且可以取得被删除的元素的值
ret2 = lst.pop(1) # 也可以指定索引删除
print(ret1) # 格斗家
print(ret2) # 神枪手
print(lst) # ["鬼剑士", "召唤师", "圣职者"]
lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
lst.remove("圣职者") # 指定列表中的元素名称进行删除,删除不存在的元素会报错
print(lst) # ["鬼剑士", "神枪手", "召唤师", 格斗家"]
lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
del lst[2] # 使用del删除指定的列表元素,只能使用索引或者切片进行删除
print(lst) # ["鬼剑士", "神枪手", "圣职者", "格斗家"]
lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
lst.clear() # 清空列表
print(lst) # []
改
lst = ["马云", "马化腾", "马良", "马蓉", "马克思"]
lst[1] = "麻花藤"
print(lst) # ["马云", "麻花藤", "马良", "马蓉", "马克思"]
lst = ["马云", "马化腾", "马良", "马蓉", "马克思"]
lst[1:4] = "hello"
print(lst) # ["马云", "h", "e", "l", "l", "o", "马克思"]
查
列表是一个可迭代对象,所以可以使用for循环查询
for ele in list:
print(i)
其它操作
# 计算"行者孙"在列表中出现的次数
lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
print(lst.count("行者孙")) # 2
# 计算列表的长度
lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
print(len(lst)) # 4
# 对列表元素进行翻转
lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
lst.reverse()
print(lst) # ["行者孙", "者行孙", "行者孙", "孙行者"]
# 对列表进行排序
lst = [10,2,45,64,4,16,8]
lst.sort() # 默认从小到大排序
print(lst) # [2, 4, 8, 10, 16, 45, 64]
lst.sort(reverse=True) # 加上参数reverse=True变成从大到小排序
print(lst2) # [64, 45, 16, 10, 8, 4, 2]
4、列表的嵌套
lst = [1, "夸父", "dogfa", ["jack ma", ["康帅博"], "麻辣干子"]]
# 找到"夸父"
print(lst[1])
# 找到“夸父“和”dogfa”
print(lst[1:3])
# 将"夸父“替换成”夸母”
lst[1] = lst[1].replace("父", "母")
print(lst)
# 将”jack ma“各个首字母大写
lst[3][0] = lst[3][0].title()
print(lst)
# 将”康帅博“替换成”康师傅“
lst[3][1][0] = lst[3][1][0].replace("帅博", "师傅")
print(lst)
# 将”dogfa“首字母大写
lst[2] = lst[2].capitalize()
print(lst)
5、循环删除列表中的元素(注意)
lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
for i in lst:
lst.remove(i)
print(lst) # ['神枪手', '圣职者']
# 为什么我们进行for循环时没有将列表中的元素全部删除?因为for循环每循环一次内部索引会加1,而删除了列表中的元素之后,后面的元素会前移,导致删除错乱。
# 第一次循环: ["神枪手", "召唤师", "圣职者", "格斗家"] 删除索引0对应的元素,后面的元素前移
# 第二次循环: ["神枪手", "圣职者", "格斗家"] 删除索引1对应的元素,后面的元素前移
# 第三次循环: ["神枪手", "圣职者"] 删除索引2对应的元素,后面的元素前移
# 解决办法1
for i in range(len(lst)):
lst.pop()
print(lst) # []
# 解决办法2
lst2 = []
for i in lst:
lst2.append(i)
for el in lst2:
lst.remove(el)
print(lst) # []
元组: 俗称不可变的列表.?被成为只读列表, 元组也是python的基本数据类型之?, ??括
号括起来, ??可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 但就是不能
改.
tu = ("name", "age", "gender")
print(tu) # ("name", "age", "gender")
print(tu[0]) # name
print(tu[2]) # gender
print(tu[0:2]) # 元祖切片之后还是元祖
# for循环遍历元祖
for ele in tu:
print(ele)
# 尝试修改元祖
tu[0] = "我就是要改变你" # TypeError: 'tuple' object does not support item assignment (元祖中的元素不支持被修改)
# 再次尝试修改元祖
tu = ("你改不了我的", [], "你也改不了我的", "我们中出了一个叛徒")
tu[1] = "我是叛徒" # 再次修改失败
tu[1].append("我是叛徒") # 修改成功
print(tu) # ("你改不了我的", ["我是叛徒"], "你也改不了我的", "我们中出了一个叛徒")
# 通过以上结论,我们可以得出:元祖的不可变指的是元祖内的子元素不可变,而子元素的子元素可不可变取决于是否是可变类型的对象。
# 注意:当元祖中只有一个元素时,必须在元素后面加上一个逗号,否则就不是元祖,例:tu = ("name",)
# 元祖同样含有len(), index(), count()方法。
1、字典的简单介绍
字典(dict)是Python中唯?的?个映射类型.他是以{ }括起来的键值对组成. 在dict中key是
唯?的. 在保存的时候, 根据key来计算出?个内存地址. 然后将key-value保存在这个地址中.
这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key‘必须是可hash的。
可hash的数据类型:int,str,bool,tuple
不可hash的数据类型:list,dict,set
语法:{key: value, key2: value2 ...}
注意: key必须是可哈希(不可变类型)的. value没有要求.可以保存任意类型的数据
# 以下为正确字典格式
dic = {1: 123, "name": "oldniu", False: True, (1, 2, 3): (11, 22, 33)}
print(dic[1])
print(dic["name"])
print(dic[False])
print(dic[(1, 2, 3)])
# 以下是不正确的字典格式
dic = {[1, 2]: "我咋就不合法呢"} # TypeError: unhashable type: 'list'
dic = {{"name": "dogfa"}: "兄嘚我也是不合法的"} # TypeError: unhashable type: 'dict'
dic = {{"age", "hobby"}: "想不到吧,我也是不合法的"} # TypeError: unhashable type: 'set'
注意:dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ?hash表
不是连续的. 所以不能进?切片?作. 它只能通过key来获取dict中的数据
2、字典的其它相关操作
增
dic = {"age": 18}
dic["name"] = "李白"
print(dic) # {"name": "李白", "age": 18}
dic["age"] = 20
print(dic) # {"name": "李白", "age": 20}
# 如果key不存在,则是执行添加操作,如果key存在,则是执行修改操作
dic = {"age": 18}
print(dic.setdefault("name", "杜甫")) # 杜甫
print(dic) # {"age": 18, "name": "杜甫"}
print(dic.setdefault("age", 20)) # 18
print(dic) # {"age": 18, "name": "杜甫"}
# setdefault()的第一个参数为key,第二个参数为value。如果key不存在,则执行添加操作并返回对应的value,如果key存在,则执行查询操作返回字典中对应的key的value。
删
dic = {"name": "Jack Ma", "age": 38, "gender": "man"}
print(dic.pop("name")) # Jack Ma
print(dic) # {"age": 38, "gender": "man"}
# 因为dict在存储时不是连续的,所以pop在删除时不能指定索引,须指定key进行删除并会返回当前值。
dic = {"name": "Jack Ma", "age": 38, "gender": "man"}
del dic["name"]
print(dic) # {"age": 38, "gender": "man"}
dic.popitem() # 随机删除
dic.clear() # 清空字典
改
dic1 = {"id": 1, "name": "马云", "salary": 100000000}
dic2 = {"age": 38, "name": "马化腾"}
dic1.update(dic2) # 将dict2中的内容更新值dict1中,如果key存在则覆盖,key不存在则添加
print(dic1) # {'id': 1, 'name': '马化腾', 'salary': 100000000, 'age': 38}
print(dic2) # {'age': 38, 'name': '马化腾'}
查
dic = {"id": 1, "name": "电视机", "price": 1000}
print(dic["price"]) # 1000
print(dic["age"]) # 报错
print(dic.get("name")) # 电视机
print(dic.get("age")) # None
print(dic.get("age", 20)) # 20
# 当直接对字典通过key取值时,如果存在key,可以取出对应的值,如果不存在key,则会报错。所以建议使用get()方法,当key不存在时,它会返回一个None,你也可以在下一个参数指定key不存在时的返回值。
print(dic.setdefault("name")) # 电视机
其它相关操作
dic = {"id": 1, "fruit": "apple", "price": 10}
print(dic.keys()) # dict_keys(['id', 'fruit', 'price'])
for key in dic.keys():
print(key)
print(dic.values()) # dict_values([1, 'apple', 10])
for value in dic.values():
print(value)
# dic.keys()和dic.values()得到的值和列表很像,但是不是列表,但可以当做列表来进行for循环使用。
for i in dic:
print(i,dic[i])
# id 1
==> # fruit apple
# price 10
# 当对字典进行for循环时,得到的元素是key。
print(dic.items()) # dict_items([('id', 1), ('fruit', 'apple'), ('price', 10)])
for k,v in dic.items():
print(k,v)
# id 1
==> # fruit apple
# price 10
# dic.items()得到的是类似列表里面嵌套元祖的格式,对dic.items()进行for循环时,得到了里面的元祖。
# 由于 a, b = (1, 2)可以推出 k, v = ("id", 1),所以k,v 分别对应字典中的key和value。
字典的嵌套
dic = {
"id": 9527,
"name": "周星星",
"age": 40,
"movies": ["功夫", "少林足球", "算死草", "逃学威龙"],
"partner": {
"name": "逼王达",
"age": 45,
"children": ["老大", "老二", "老三"]
},
"desc": "别人笑我太疯癫,我笑他人看不穿"
}
# 获取"别人笑我太疯癫,我笑他人看不穿"
print(dic["desc"])
# 获取周星星的合作伙伴名字
print(dic.get("partner").get("name"))
# 获取“逃学威龙”
print(dic.get("movies")[3])
# 获取逼王达的第二个孩子名字
print(dic.get("partner").get("children")[1])
字典中的fromkeys()(注意)
dic = dict.fromkeys(["dogfa", "oldniu"], (1, 2))
print(dic) # {"dogfa": (1, 2), "oldniu": (1, 2)}
# fromkeys()用于重新生成一个新的字典,第一个参数中的每一项都会作为新的字典的key,第二个参数作为value。
dic = dict.fromkeys(["dogfa", "oldniu"], [1, 2])
dic.get("dogfa").append(3)
print(dic) # {"dogfa": [1, 2, 3], "oldniu": [1, 2, 3]}
set集合是python的?个基本数据类型. ?般不是很常?. set中的元素是不重复的.?序的.?
?的元素必须是可hash的(int, str, tuple,bool), 我们可以这样认为, set就是dict类型的数据但
是不保存value, 只保存key. set也?{}表?。
注意:set中的元素必须是可hash的,但是set本身不是可hash的,set是可变类型数据。
set = {1, "2", True, [1, 2]} # TypeError: unhashable type: 'list'
set = {1, "2", True, {1: 2}} # TypeError: unhashable type: 'dict'
set = {1, "2", True, {1, 2}} # TypeError: unhashable type: 'set'
由于set中的元素是不重复的,无序的,所以我们可以利用这个特性对列表进行去重操作。
lst = ["哈哈哈", 1, "嘿嘿嘿", "哈哈哈", "dsb", True, 1]
print(list(set(lst))) # [1, 'dsb', '嘿嘿嘿', '哈哈哈']
set的相关操作
增
s = {1, 2, 3}
s.add(4)
print(s) # {1, 2, 3, 4}
s = {1, 2, 3}
s.update([4, 5, 6]) # 迭代更新
print(s) # {1, 2, 3, 4, 5, 6}
# 已存在的元素将不会被添加进去
删
s = {1, 2, 3}
s1 =s.pop() # 随机删除
print(s) # {2, 3}
print(s1) # 1
s = {1, 2, 3}
s.remove(2)
print(s) # {1, 3}
# 对不存在的元素进行删除时将会报错
s = {1, 2, 3}
s.clear()
print(s) # set()
# 清空之后打印输出的是set(),是为了和dict区分开
改
# 由于集合是没有索引,无序的,所以我们对几个进行删除时不能通过索引的方式来删除
# 修改方法1:首先通过remove()删掉需要修改的的元素,然后add()添加新元素。
s = {1, 2, 3} # 将1改成10
s.remove(1)
s.add(10)
print(s) # {10, 2, 3}
# 修改方法2:将集合通过list()转换成列表,再通过对列表进行修改操作。
查
for i in s:
print(i)
其它常用操作
# 求两个集合中的交集
s1 = {"狗法", "oldniu", "djb"}
s2 = {"狗法", "oldniu", "djb", "dsb"}
print(s1.intersection(s2)) # {"狗法", "oldniu", "djb"}
print(s1 & s2) # {"狗法", "oldniu", "djb"}
# 求两个集合中的并集
s1 = {"狗法", "oldniu", "djb"}
s2 = {"狗法", "oldniu", "djb", "dsb"}
print(s1.union(s2)) # {"狗法", "oldniu", "djb", "dsb"}
print(s1 | s2) # {"狗法", "oldniu", "djb", "dsb"}
原文:https://www.cnblogs.com/wangyueping/p/11026020.html