Python的基本数据类型
python学习基础数据类型
一 、字符串str
Python中凡是用引号一起来的数据可以称为字符串类型，组成字符串的每个元素称为字符，讲这些字符一个一个连接起来，然后在用引号引起来就是字符串。
1、字符串的索引与切片
组成字符串的字符从左至右，依次排序，他们都是有顺序的，从左至右依次为：0,1,2,3……；从右至左依次为：-1,-2,-3……
a = 'ABCDEFGHIJK'
print(a[0]) # A
print(a[3]) # D
print(a[5]) # F
print(a[7]) # H
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
a = 'ABCDEFGHIJK'
print(a[0:3]) # ABC 从开头开始取0可以默认不写
print(a[2:5]) # CDE
print(a[:]) # ABCDEFGHIJK 默认到最后
print(a[:-1]) # ABCDEFGHIJ 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[:5:2]) # ACE加步长
print(a[-1:-6:-2]) # KIG 反向加步长
2、字符串常用方法
字符串除了可以用切片（步长）之外，还有一些其他的操作方法。
# 数字符串中的元素出现的个数。
a1 = "abacdefj"
ret3 = a1.count("a", 0, 4) # 可切片
print(ret3) # 2
a4 = "dkfjdkfasf54"
# startswith 判断是否以...开头
# endswith 判断是否以...结尾
ret4 = a4.endswith('jdk', 3, 6) # 顾头不顾腚
print(ret4) # 返回的是布尔值
ret5 = a4.startswith("kfj", 1, 4)
print(ret5)
# split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
ret9 = 'title,Tilte,atre,'.split('t')
print(ret9) # ['', 'i', 'le,Til', 'e,a', 're,']
ret91 = 'title,Tilte,atre,'.rsplit('t', 1)
print(ret91) # ['title,Tilte,a', 're,']
# format的三种玩法 格式化输出
res1 = '{} {} {}哈哈哈'.format('shijie', 18, 'male')
res2 = '{1} {0} {1}哈哈哈'.format('shijie', 18, 'male')
res3 = '{name} {age} {sex}哈哈哈'.format(sex='male', name='shijie', age=18)
print(res1) # shijie 18 male哈哈哈
print(res2) # 18 shijie 18哈哈哈
print(res3) # shijie 18 male哈哈哈
# strip 删除指定两端的字符，默认是删除两端的空格
name = '*barry**'
print(name.strip('*')) # barry
print(name.lstrip('*')) # barry**
print(name.rstrip('*')) # *barry
# replace
name = 'alex say :i have one tesla,my name is alex'
print(name.replace('alex', 'SB', 1))
# is系列 返回值是True，False
name = 'shijie123'
print(name.isalnum()) # True 字符串由字母或数字组成
print(name.isalpha()) # False 字符串只由字母组成
print(name.isdecimal()) # False 字符串只由十进制组成
# 寻找字符串中的元素是否存在
a4 = "dkfjdkfasf54"
ret6 = a4.find("f") # 2 从左边查找
ret6 = a4.rfind("f") # 从右边查找返回索引值
print(ret6) # 9 返回的找到的元素的索引，如果找不到返回-1
ret61 = a4.index("dk", 4, 6)
print(ret61) # 4 返回的找到的元素的索引，找不到报错。
# captalize,swapcase,title
name = 'shijie123 shuYIN'
print(name.capitalize()) # Shijie123 shuyin 首字母大写
print(name.swapcase()) # SHIJIE123 SHUyin 大小写翻转
msg = 'shijie say hi'
print(msg.title()) # Shijie Say Hi 每个单词的首字母大写
# 内同居中，总长度，空白处填充
ret2 = a1.center(20, "*")
print(ret2) # ******abacdefj******
二 、列表list
列表是python的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中的也叫数组，他是以[]括起来，每个元素以逗号隔开，而且它里面可以存放各种数据类型比如：元组、字符串、数字、列表、字典。列表相比于字符串，不仅可以存储不同的数据类型，而且还可以存储大量数据，32位python的限制是536870912个元素，64位python的限制是1152921504606846975个元素。而且列表是有序的，有索引值，可切片，方便取值。
1、列表的创建
# 创建一个列表有三种方式：
# 方式一：（常用）
l1 = [1,2,3,"xsir"]
# 方式二：
l1 = list() # 空列表 括号里可以放可迭代对象iterable
l1 = list("123")
print(l1) # ['1', '2', '3']
#方式三：列表推导式
l1 = [i for i in range(1,5)]
print(l1) # [1, 2, 3, 4]
2、列表的索引切片
l1 = ['a', 'b', 'c', '1', '2', '3']
print(l1[0]) # a
print(l1[-1]) # 3
print(l1[0:3]) # ['a', 'b', 'c']
print(l1[:-1]) # ['a', 'b', 'c', '1', '2']
print(l1[::2]) # ['a', 'c', '2']
print(l1[::-1]) # ['3', '2', '1', 'c', 'b', 'a']
3、增
# append 追加，给列表的最后面追加一个元素
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]
# insert 插入在列表的任意位置插入元素
# 超出索引值，默认插入在列表的最后一位
l = [1, 2, 'a']
l.insert(1,'世界')
print(l) # [1, '世界', 2, 'a']
# extend 迭代着追加，在列表的最后面迭代着追加一组数据
l = [1, 2, 'a']
l.extend('世界a')
print(l) # [1,2,'a','世'，'界'，'a']
4、删
# pop 通过索引删除列表中对应的元素，默认是最后一个值，返回值为删除的元素
l = ['班长', 'xubin', 'XiaoSir', '女神']
ret = l.pop(1)
print(ret, l) # xubin ['班长', 'XiaoSir', '女神']
# remove 通过元素删除列表中该元素 删除有多个一样的值，只删除第一个
# 删除的值不存在时报错
l = ['班长', 'xubin', 'XiaoSir', '女神']
l.remove('xubin')
print(l) # ['班长', 'XiaoSir', '女神']
# clear 清空列表
l = ['班长', 'xubin', 'XiaoSir', '女神']
l.clear()
print(l) # []
# del 按照索引删除该元素 超出索引值是报错
l = ['班长', 'xubin', 'XiaoSir', '女神']
del l[2]
print(l) # ['班长', 'xubin', '女神']
# 切片删除该元素
l = ['班长', 'xubin', 'XiaoSir', '女神']
del l[1:]
print(l) # ['班长']
# 切片(步长)删除该元素
l = ['班长', 'xubin', 'XiaoSir', '女神']
del l[::2]
print(l) # ['xubin', '女神']
5、改
# 按照索引改值
l = ['班长', 'xubin', 'XiaoSir', '女神']
l[0] = '男神'
print(l) # ['男神', 'xubin', 'XiaoSir', '女神']
# 按照切片改值(迭代着增加)
l = ['班长', 'xubin', 'XiaoSir', '女神']
l[1:3] = 'abcdefg'
print(l) # ['班长', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神']
# 按照切片(步长)改值(必须一一对应)
l = ['班长', 'xubin', 'XiaoSir', '女神']
l[::2] = '对应'
print(l) # ['对', 'alex', '应', '女神']
6、查
切片或者循环去查
7、列表的其他操作
# count() 统计某个元素在列表中出现的次数
a = ['a', 'b', 'c', 'd', 'b', 'a']
print(a.count('a')) # 2
# index(） 从列表中找出某个值第一个匹配项的索引位置
a = ['a', 'b', 'c', 'd', 'b', 'a']
print(a.index('b')) # 1
# sort 在原位置对列表进行排序 默认是升序
b = [1, 2, 3, 5, 4, 8, 7]
b.sort(reverse=True)
print(b) # [8, 7, 5, 4, 3, 2, 1]
b.sort()
print(b) # [1, 2, 3, 4, 5, 7, 8]
# sorted 对列表排序返回一个新列表
# reverse默认值是False升序，True降序排序
b = [1, 2, 3, 5, 4, 8, 7]
print(sorted(b, reverse=True)) # [8, 7, 5, 4, 3, 2, 1]
# reverse 将列表中的元素反向存放
b = [1, 2, 3, 5, 4, 8, 7]
b.reverse()
print(b) # [7, 8, 4, 5, 3, 2, 1]
# 列表也可以相加，和整数相乘
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1+l2) # [1, 2, 3, 4, 5, 6]
print(l1*3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
三、元组tuple
对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能看而不能增删改查，这种数据类型就是元组。
元组：俗称不可变的列表，又被称为只读列表，元组也是python的基本数据类型之一，用小括号括起来，里边可以放任何数据类型的数据，查询可以，循环也可以，切片也可以，但就是不能更改。
python中元组有一个特性，元组中如果只含有一个元素且没有逗号，则该元组不是元组，与该元素数据类型一致，如果有逗号，那么它是元组。
1、元组的索引切片
tu1 = ('a', 'b', 3, 666, '女神')
print(tu1[0]) # a
print(tu1[-1]) # 女神
print(tu1[1:3]) # ('b', 3)
print(tu1[:-1]) # ('a', 'b', 3, 666)
print(tu1[::2]) # ('a', 3, '女神')
print(tu1[::-1]) # ('女神', 666, 3, 'b', 'a')
2、元组的其他操作
# 可以利用for循环查询
tu1 = ('a', 'b', '太白', 3, 666)
for i in tu1:
print(i)
# index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。
tu = ('班长', [1, 2, 3, ], 'XiaoSir', '女神')
print(tu.index('班长')) # 0
# 元组的长度
tu = ('班长', [1, 2, 3, ], 'XiaoSir', '女神')
print(len(tu)) # 4
四、字典dict
列表有哪些缺点：1. 列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢2. 列表只能按照顺序存储，数据与数据之间关联性不强数据类型可以按照不同的角度进行分类，按照可变与不可变的数据类型的分类：
- 不可变（可哈希）的数据类型：int，str，bool，tuple
- 可变（不可哈希）的数据类型：list，dict，set
字典是Python语言中的映射类型，他是以{}括起来，里面的内容是以键值对的形式储存的：
- Key: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。
- Value:任意数据(int，str，bool，tuple，list，dict，set)。
在Python3.5版本（包括此版本）之前，字典是无序的。在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。当然，字典也有缺点：他的缺点就是内存消耗巨大。
1、创建字典的几种方式
# 方式1:
# dic = dict((('one', 1),('two', 2),('three', 3)))
dic = dict([('one', 1),('two', 2),('three', 3)])
# dic = dict([['a', 'b'], ['c', 'd']])
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式2:
# dic = dict(one=1,two=2,three=3)
# print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式3:
# dic = dict({'one': 1, 'two': 2, 'three': 3})
# print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式5:
# dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
# print(dic)
# 方式6: 字典推导式
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)
# 方式7:利用fromkey
# dic = dict.fromkeys('abcd','女神')
# print(dic) # {'a': '女神', 'b': '女神', 'c': '女神', 'd': '女神'}
# 这里有一个坑，就是如果通过fromkeys得到的字典的值为可变的数据类型，那么你的小心了。
dic = dict.fromkeys([1, 2, 3], [])
dic[1].append(666)
print(id(dic[1]),id(dic[2]),id(dic[3])) # {1: [666], 2: [666], 3: [666]}
print(dic) # {1: [666], 2: [666], 3: [666]}
2、增
# 通过键值对直接增加
dic = {'name': 'XiaoSir', 'age': 18}
dic['weight'] = 75 # 没有weight这个键，就增加键值对
print(dic) # {'name': 'XiaoSir', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name这个键，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}
# setdefault
dic = {'name': 'XiaoSir', 'age': 18}
dic.setdefault('height', 175) # 没有height此键，则添加
print(dic) # {'name': 'XiaoSir', 'age': 18, 'height': 175}
dic.setdefault('name', 'barry') # 有此键则不变
print(dic) # {'name': 'XiaoSir', 'age': 18, 'height': 175}
# 它有返回值
dic = {'name': 'XiaoSir', 'age': 18}
ret = dic.setdefault('name')
print(ret) # XiaoSir
3、删
# pop 通过key删除字典的键值对，有返回值，可设置返回值。
dic = {'name': 'XiaoSir', 'age': 18}
# ret = dic.pop('name')
# print(ret,dic) # XiaoSir {'age': 18}
ret1 = dic.pop('n',None)
print(ret1, dic) # None {'name': 'XiaoSir', 'age': 18}
# popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值
dic = {'name': 'XiaoSir', 'age': 18}
ret = dic.popitem()
print(ret, dic) # ('age', 18) {'name': 'XiaoSir'}
# clear 清空字典
dic = {'name': 'XiaoSir', 'age': 18}
dic.clear()
print(dic) # {}
# del 通过键删除键值对
dic = {'name': 'XiaoSir', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
# 删除整个字典
del dic
4、改
# 通过键值对直接改
dic = {'name': 'XiaoSir', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}
# update
dic = {'name': 'XiaoSir', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': 'XiaoSir', 'age': 18, 'sex': '男', 'height': 175}
dic = {'name': 'XiaoSir', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': 'XiaoSir', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic1 = {"name": "jin", "age": 18,"sex": "male"}
dic2 = {"name": "XiaoSir", "weight": 75}
dic1.update(dic2)
print(dic1) # {'name': 'XiaoSir', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'XiaoSir', 'weight': 75}
5、查
# 通过键查询 直接dic[key](没有此键会报错)
dic = {'name': 'XiaoSir', 'age': 18}
print(dic['name']) # XiaoSir
# get
dic = {'name': 'XiaoSir', 'age': 18}
v = dic.get('name')
print(v) # 'XiaoSir'
v = dic.get('name1')
print(v) # None
v = dic.get('name2', '没有此键')
print(v) # 没有此键
# keys()
dic = {'name': 'XiaoSir', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age'])
# values()
dic = {'name': 'XiaoSir', 'age': 18}
print(dic.values()) # dict_values(['XiaoSir', 18])
# items()
dic = {'name': 'XiaoSir', 'age': 18}
print(dic.items()) # dict_items([('name', 'XiaoSir'), ('age', 18)])
五、集合
集合是无序的，不重复的数据集合，它里面的元素是不可哈希的（不可变类型），但是集合本身是不可哈希的，集合有个重要的点：
- 去重，把一个列表变成集合，就自动去重了
- 关系测试测试两组数据之间的交集、差集、并集等关系。
1、集合的创建
set1 = set({1,2,'hah'})
set2 = {1,2,'hah'}
print(set1,set2) # {1, 2, 'hah'} {1, 2, 'hah'}
2、增
# add
set1 = {'a', 'b', 'c', 'd', 'e'}
set1.add('hah')
print(set1)
# update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)
3、删
set1 = {'a', 'b', 'c', 'd', 'e'}
set1.remove('b') # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
4、集合的其他操作
# 交集（& 或者 intersection）
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
# 并集 （| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}
# 差集（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
# 反交集 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
# 子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2) # True
print(set1.issubset(set2)) # True这两个相同，都是说明set1是set2子集。
print(set2 > set1) # True
print(set2.issuperset(set1)) # True 这两个相同，都是说明set2是set1超集。
5、不可变集合
s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
浙公网安备 33010602011771号