Python基本数据类型

Python基本数据类型

一、Python基本数据类型

  1. int ==> 整数. 主要⽤来进⾏数学运算

  2. str ==> 字符串, 可以保存少量数据并进⾏相应的操作

  3. bool==>判断真假, True, False

  4. list==> 存储⼤量数据.⽤[ ]表⽰

  5. tuple=> 元组, 不可以发⽣改变 ⽤( )表⽰

  6. dict==> 字典, 保存键值对, ⼀样可以保存⼤量数据

  7. set==> 集合, 保存⼤量数据. 不可以重复. 其实就是不保存value的dict

二、整数（int）

在Python 3 中所有的整数都是int类型，但在Python 2 中如果数据量较大则会采用 long类型，而在Python 3 中没有long类型。

常用方法：

​ 1、bit_length()：计算整数在计算机中占用的二进制数的长度。

三、布尔值（bool）

取值只有True和False。

转换问题：

  1. str ==> int int(str)
  2. int ==> str str(int)
  3. int ==> bool bool(int) 0为False，非0位True
  4. bool ==> int int(bool) True为1，False为0
  5. str ==> bool bool(str) 空为False，非空为True
  6. bool ==> str str(bool) 把bool值转换成相应的"值"

四、字符串（str）

字符串：把字符连成串. 在python中⽤', ", ''', """引起来的内容被称为字符串.

  1. 索引和切片

    索引：索引指的就是下标，索引从0开始。

    切片：截取字符串指定部分的内容。

    ​ 语法：str[起始位置，结束位置，步长]

    ​ 规则：“顾头不顾尾”，即包含起始位置，但不包含结束位置。

    ​ 步长：如果是整数，则从左往右取，如果是负数，则从右往左取，默认是1。

    content = "生活不止眼前的苟且，以后还有一大堆的苟且。"
例：截取“眼前的苟且，以后还有”
print(content[4:14])
例：截取“生不眼的且以还一堆苟”
print(content[::2])
例：将内容翻转
print(content[::-1])
例：截取“一有还后以，且苟的前”
print(content[14:4:-1])
例：截取“止眼前的苟且，以后还有一大堆的苟且。”
print(content[3:])

  2. 字符串其它相关方法

    注意：切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的。

    1. 字符串中的字母全部大写

      content = “dogfa is a verv beautiful boy!”
content = content.upper()
print(content)
==>"DOGFA IS A VERV BEAUTIFUL BOY!"

    2. 字符串中的字母全部小写

      content = “DOGFA IS A VERV BEAUTIFUL BOY!”
content = content.lower()
print(content)
==>"dogfa is a verv beautiful boy!"

    3. 英文首字母大写

      content = “dogfa is a verv beautiful boy!”
content = content.capitalize()
print(content)
==>"Dogfa is a verv beautiful boy!"

    4. 大小写转换

      content = “dOgfA iS A verv beautiful boy!”
content = content.swapcase()
print(content)
==>"DoGFa Is a VERV BEAUTIFUL BOY!"

    5. 每个被特殊字符隔开的单词首字母大写

      content = "dogfa is a verv beautiful boy!"
content = content.title()
print(content)
==>"Dogfa Is A Verv Beautiful Boy!"

    6. 居中

      content = "欢迎光临~"
content = content.center(15, "*")		#将长度拉长为15，两边用‘*’填充
print(content)
==> "*****欢迎光临~*****"

    7. 清除空格

      content = "   其实世上本没有路，走的人多了也就成了路     "
content = content.strip()		#清楚两端空格
print(content)
==> "其实世上本没有路，走的人多了也就成了路"

str.lstrip()		# 清除左端空格
str.rstrip()		# 清楚右端空格
str.strip("明")	    # 清除左右两端的“明”

content = "明天到操场操到天明"
content = content.strip("明")
print(content)
==> "天到操场操到天"

    8. 字符串替换

      content = "明天到操场操到天明"
content = content.replace("操", "*")
print(content)
==> "明天到*场*到天明"

str.replace("需要替换的字符串", "替换为的字符串", "替换数量")	# 替换数量默认为全部替换
content = content.replace("操", "*", 1)
print(content)
==> "明天到*场操到天明"

    9. 字符串切割

      content = "清明时节雨纷纷，路上行人欲断魂，借问酒家何处有，牧童遥指杏花村"
content = content.split("，")
print(content)
==> "['清明时节雨纷纷', '路上行人欲断魂', '借问酒家何处有', '牧童遥指杏花村']"

content = content.split("清")
print(content)
==> "['', '明时节雨纷纷，路上行人欲断魂，借问酒家何处有，牧童遥指杏花村']"

注意：如果切割点在开头或者结尾，都将会在列表的开头或结尾产生一个空字符串。

    10. 格式化输出

      例：要求输入以下内容
*********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))

    11. 查找

      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

    12. 条件判断

      # 判断是否为纯数字
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

    13. 计算字符串的长度

      content = "你猜我有多长？"
print(len(content))
==> 7

注意：注意: len()是python的内置函数. 所以访问⽅式也不⼀样。

    14. 字符串的拼接

      content = "嘿嘿嘿"
content = "_".join(content)
print(content)		# 嘿_嘿_嘿

    15. 迭代

      for "变量" in "可迭代对象":
	pass
	
 
content = "喜欢唱跳rap篮球"
for item in content:
    print(item)
    
==> 喜
    欢
    唱
    跳
    r
    a
    p
    篮
    球

 
可迭代对象：简单来说就是可以一个一个往外取值的对象，如str, list, tuple。

五、列表（list）

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、列表的增删该查

注意：列表是可变类型，所以可以直接对列表中的元素进行操作。

  1. 增

    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']

  2. 删

    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)		# []

  3. 改

    lst = ["马云", "马化腾", "马良", "马蓉", "马克思"]
lst[1] = "麻花藤"
print(lst)		# ["马云", "麻花藤", "马良", "马蓉", "马克思"]

lst = ["马云", "马化腾", "马良", "马蓉", "马克思"]
lst[1:4] = "hello"
print(lst)		# ["马云", "h", "e", "l", "l", "o", "马克思"]

  4. 查

    列表是一个可迭代对象，所以可以使用for循环查询

    for ele in list:
	print(i)

  5. 其它操作

    # 计算"行者孙"在列表中出现的次数
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)		# []

六、元祖（tuple）

元组: 俗称不可变的列表.⼜被成为只读列表, 元组也是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()方法。

七、字典（dict）

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、字典的其它相关操作

  1. 增

    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。

  2. 删

    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()		# 清空字典

  3. 改

    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': '马化腾'}

  4. 查

    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"))	# 电视机

  5. 其它相关操作

    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。

  6. 字典的嵌套

    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])

  7. 字典中的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）

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的相关操作

  1. 增

    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}
# 已存在的元素将不会被添加进去

  2. 删

    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区分开

  3. 改

    # 由于集合是没有索引，无序的，所以我们对几个进行删除时不能通过索引的方式来删除
# 修改方法1：首先通过remove()删掉需要修改的的元素,然后add()添加新元素。
s = {1, 2, 3}	# 将1改成10
s.remove(1)
s.add(10)
print(s)	# {10, 2, 3}

# 修改方法2：将集合通过list()转换成列表，再通过对列表进行修改操作。

  4. 查

    for i in s:
	print(i)

  5. 其它常用操作

    # 求两个集合中的交集
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"}
posted @ 2019-06-15 00:20  与鹿逐秋  阅读(416)  评论(0)  编辑  收藏  举报