㈠ 二级Python----组合数据类型（DAY 5）
1.集合类型概述
Python语言中的集合类型与数学中的集合概念一致，即包含0个或多个数据项的无序组合。
集合是无序组合，用大括号{}表示，它没有索引和位置的概念，集合中元素可以动态增加或删除。
由于集合元素独一无二，使用集合类型能够过滤掉重复元素。
集合类型有4个操作符，交集&、并集|、差集-、补集^，操作逻辑与数学定义相同
集合类型有一些常用的操作函数或方法
set()函数将其他的组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合。set()函数也可以生成空集合变量。
列表类型用中括号[]表示，也可以通过list(x)函数将集合或字符串类型转换成列表类型。
列表属于序列类型，所以列表类型支持序列类型对应的操作
1.序列类型有一些通用的操作符和函数
2.列表的索引
索引是列表的基本操作，用于获得列表的一个元素。使用中括号作为索引操作符。
可以使用遍历循环对列表类型的元素进行遍历操作，
基本使用方式如下
3.列表的切片
切片是列表的基本操作，用于获得列表的一个片段，即获得一个或多个元素。切片后的结果也是列表类型。
切片的使用方式：
切片获取列表类型从N到M（不包含M）的元素组成新的列表。当K存在时，切片获取列表类型从N到M（不包含M）以K为步长所对应元素组成的列表。
1.列表的操作方法
ls.append(x)仅用于在列表中增加一个元素，如果希望增加多个元素，可以使用加号+，将两个列表合并。
可以使用Python保留字del对列表元素或片段进行删除。
如下：
或
使用索引配合等号（=）可以对列表元素进行修改。
补：元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号()，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
Python语言中的字典使用大括号{}建立，每个元素是一个键值对。
使用方式：
键和值通过冒号连接，不同键值对通过逗号隔开。大括号可以表示集合，字典类型也具有和集合类似的性质，即键值对之间没有顺序且不能重复。
•字典的索引
列表类型采用元素顺序的位置进行索引。由于字典元素“键值对”中键是值的索引，因此，可以直接利用键值对关系索引元素。
利用索引和赋值 = 配合，可以对字典中每个元素进行修改。
使用大括号可以创建字典。通过索引和赋值配合，可以向字典中增加元素。
字典类型有一些通用的操作函数
字典类型存在一些操作方法
d.keys()返回字典中的所有键信息，返回结果是Python的一种内部数据类型dict_keys，专用于表示字典的键。如果希望更好的使用返回结果，可以将其转换为列表类型。
d.values()返回字典中的所有值信息，返回结果是Python的一种内部数据类型dict_values。如果希望更好的使用返回结果，可以将其转换为列表类型。
d.items()返回字典中的所有键值对信息，返回结果是Python的一种内部数据类型dict_items。
d.get(key, default)根据键信息查找并返回值信息，如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空。
d.pop(key, default)根据键信息查找并取出值信息，如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空。相比d.get()方法，d.pop()在取出相应值后，将从字典中删除对应的键值对。
d.popitem()随机从字典中取出一个键值对，以元组(key,value)形式返回。取出后从字典中删除这个键值对。
d.clear()删除字典中所有键值对。
此外，如果希望删除字典中某一个元素， 可以使用Python保留字del。
字典类型也支持保留字in，用来判断一个键是否在字典中。如果在则返回True，否则返回False。
字典可以遍历循环对其元素进行遍历
for循环返回的变量名是字典的索引值。如果需要获得键对应的值，可以在语句块中通过get()方法获得。
㈡ 5.0、python基础数据类型
python基础二（基础数据类型）
一、引子
1 什么是数据？
x=10，10是我们要存储的数据
2 为何数据要分不同的类型
数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示
3 数据类型
数字 字符串 列表 元组 字典 集合
二、基础数据类型
2.1数字int
数字主要是用于计算用的，使用方法并不是很多，就记住一种就可以：
#bit_length() 当十进制用二进制表示时，最少使用的位数
v = 11
data = v.bit_length()
print(data)
2.2布尔值bool
布尔值就两种：True，False。就是反应条件的正确与否
真 1 True
假 0 False
2.3字符串str
2.3.1、字符串的索引与切片。
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长
2.3.2、字符串常用方法
#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写
# 内同居中，总长度，空白处填充
ret2 = a1.center(20,"*")
print(ret2)
#数字符串中的元素出现的个数。
# ret3 = a1.count("a",0,4) # 可切片
# print(ret3)
a2 = "hqw\t"
#\t前面的补全
# 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
ret4 = a2.expandtabs()
print(ret4)
a4 = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
# ret4 = a4.endswith('jdk',3,6) # 顾头不顾腚
# print(ret4) # 返回的是布尔值
# ret5 = a4.startswith("kfj",1,4)
# print(ret5)
#寻找字符串中的元素是否存在
# ret6 = a4.find("fjdk",1,6)
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1
# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。
#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
# ret9 = 'title,Tilte,atre,'.split('t')
# print(ret9)
# ret91 = 'title,Tilte,atre,'.rsplit('t',1)
# print(ret91)
#format的三种玩法 格式化输出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))
#replace (替换)
replace(old, new, count)
replace('被替换的字符串','要替换的字符串',一组字符串当中替换的次数)
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
输出：SB say :i have one tesla,my name is alex
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',2))
输出：SB say :i have one tesla,my name is SB
#####is系列
name='jinxin123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成
2.4元祖tuple
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）
2.5列表list
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
2.5.1、增。
li = [1,'a','b',2,3,'a']
# li.insert(0,55) #按照索引去增加
# print(li)
#
# li.append('aaa') #增加到最后
# li.append([1,2,3]) #增加到最后
# print(li)
#
# li.extend(['q,a,w']) #迭代的去增
# li.extend(['q,a,w','aaa'])
# li.extend('a')
# li.extend('abc')
# li.extend('a,b,c')
# print(li)
2.5.2、删
# l1 = li.pop(1) #按照位置去删除，有返回值
# print(l1)
# del li[1:3] #按照位置去删除，也可切片删除没有返回值。
# print(li)
# li.remove('a') #按照元素去删除
# print(li)
# li.clear() #清空列表
2.5.3、改
# 改
# li = [1,'a','b',2,3,'a']
# li[1] = 'dfasdfas'
# print(li)
# li[1:3] = ['a','b']
# print(li)
2.5.4、查
切片去查，或者循环去查。
2.5.5、其他操作
count（数）（方法统计某个元素在列表中出现的次数）。
a = ["q","w","q","r","t","y"]
print(a.count("q"))
index（方法用于从列表中找出某个值第一个匹配项的索引位置）
a = ["q","w","r","t","y"]
print(a.index("r"))
sort （方法用于在原位置对列表进行排序）
reverse （方法将列表中的元素反向存放）
a = [2,1,3,4,5]
a.sort()# 他没有返回值，所以只能打印a
print(a)
a.reverse()#他也没有返回值，所以只能打印a
print(a)
2.6字典dict。
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
2.6.1、增
# dic['li'] = ["a","b","c"]
# print(dic)
# setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
# dic.setdefault('k','v')
# print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# dic.setdefault('k','v1') # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# print(dic)
2.6.2、删
# dic_pop = dic.pop("a",'无key默认返回值') # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
# print(dic_pop)
# del dic["name"] # 没有返回值。
# print(dic)
# dic_pop1 = dic.popitem() # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
# print(dic_pop1) # ('name','jin')
# dic_clear = dic.clear() # 清空字典
# print(dic,dic_clear) # {} None
2.6.3、改
# 改
# dic = {"name":"jin","age":18,"sex":"male"}
# dic2 = {"name":"alex","weight":75}
# dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
# print(dic2)
2.6.4、查
# value1 = dic["name"] # 没有会报错
# print(value1)
#
# value2 = dic.get("djffdsafg","默认返回值") # 没有可以返回设定的返回值
# print(value2)
2.6.5、其他操作
# item = dic.items()
# print(item,type(item)) # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'>
# 这个类型就是dict_items类型，可迭代的
# keys = dic.keys()
# print(keys,type(keys)) # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>
# values = dic.values()
# print(values,type(values)) # dict_values(['male', 18, 'jin']) <class 'dict_values'> 同上
字典的循环
# dic = {"name":"jin","age":18,"sex":"male"}
# for key in dic:
# print(key)
# for item in dic.items():
# print(item)
# for key,value in dic.items():
# print(key,value)
三，基础数据类型的总结
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息 set() { }
元组：有序，需要存索引相关信息，不可变 ( )
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改 [ ]
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改 { }
按存值个数区分
标量／原子类型数字，字符串
容器类型列表，元组，字典
按可变不可变区分
可变列表，字典
不可变数字，字符串，元组，布尔值
按访问顺序区分
直接访问数字
顺序访问（序列类型）字符串，列表，元组
key值访问（映射类型）字典
四，其他（for，enumerate，range）
for循环：用户按照顺序循环可迭代对象的内容
msg = '是全国范围内最好的'
for item in msg:
print(item)
li = ['alex','银角','女神','egon','太白']
for i in li:
print(i)
dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items():
print(k,v)
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name)
range：指定范围，生成指定数字
for i in range(1,10):
print(i)
for i in range(1,10,2): # 步长
print(i)
for i in range(10,1,-2): # 反向步长
print(i)
㈢ (2) python基本数据类型总结
布尔值bool
只有bool(0)和bool()括号中为空才表示Fasle。bool(’0‘)等表示True
序列
字符串 str 可用单引号，双引号或者三引号表示例如'str' 或"str "或者'''str'''
其中三引号常用方式如下
在字符串前面加一个R/r 表示原始字符串
一些转义字符（特殊的字符）
元组 tuple ( )与列表list [ ]
元组与列表在python中的唯一区别就是：元组是不可变的，列表是可变的。(元组和字符串是不可变的)
在你有一些不确定长度的相同类型队列的时候使用列表；在你提前知道元素数量的情况下使用元组，因为元素的位置很重要。
序列可以进行加法，与整数相乘，切片操作
集合set {}和字典dict {}
集合和字典的特点是 无序，不重复
set()表示空集合
{} 表示空字典
字典是通过key访问value{key1:value1,key2:value2}
key 不能重复,类型为int,str，tuple
value可以为任意数据
序列和集合的其他运算
㈣ python的数据类型——列表
python中列表是最常见的一种数据类型，下面我们来看看列表的基本用法吧
列表的表示：list=[ ] 用中括号表示 或者list()
列表的作用：存储多个数据的数据类型
列表可以存储多种数据类型，可以存储任何类型的数据
列表的操作
获取列表长度len()
获取某个元素可以使用索引，索引同字符串，从头开始就是0开始，从末尾开始就是-1
列表索引后得到的数据类型就是该元素本身的类型
切片后获取的数据还是列表
列表是可变类型：可以增加，修改和删除
列表的增加
1、列表的添加：列表最后添加一个元素 append
2、在指定位置添加索引：insert
3、同时添加多个元素：extend(相当于将两个列表合并)
列表的删除
1、删除指定的内容 remove（当列表中含有多个相同内容的元素，默认删除第一个）
2、删除指定的索引 pop
列表的修改
1、通过索引来修改
说完列表的几种操作，下面我们来看看这些操作打印出来的结果是什么：
none是一种数据类型，表示什么都没有，append得到的结果为none，remove得到的结果也是none.pop得到的结果是删除的那个元素
㈤ Python中数据类型的判断
Python在定义变量的时候不用指明具体的的类型，解释器会在运行的时候会自动检查 变量的类型，并根据需要进行隐式的类型转化。因为Python是动态语言，所以一般情 况下是不推荐进行类型转化的。比如"+"操作时，如果加号两边是数据就进行加法操 作，如果两边是字符串就进行字符串连接操作，如果两边是列表就进行合并操作，甚 至可以进行复数的运算。解释器会在运行时根据两边的变量的类型调用不同的内部方法。 当加号两边的变量类型不一样的时候，又不能进行类型转化，就会抛出TypeError的异常。
通常类型判断可用两种方法来进行判断：
这两种方法有什么区别，用哪种比较好呢？
对于内建的基本类型来说，使用tpye来检查是没有问题的， 可是当应用到其他场合的时候，type就显得不可靠了。比如：当我们对Python内建类型进行扩展的时候，type返回的结果就不够准确了。
这个时候我们就需要使用isinstance来进行类型 检查。
object表示实例，classinfo可以是直接或间接类名、基本类型或者有它们组成的元组。
㈥ 四、 python中的数据类型——列表
列表是一种有序的集合，有点类似c里面的数组。它的特点是，可以随时向里面添加或删除其中的元素，在python中经常用来存放数据。列表的特点是中括号，内部元素用逗号隔开。 在这个列表中，可以放进去任何元素，不论你的元素是字符串、整型、浮点型、还是布尔值、空值，包括列表什么的，都可以放进去。 元素与元素之间，用逗号隔开。 列表会为每个元素分配序号，这个序号代表它的位置，称为索引（index），第一个元素的位置是0，第二个元素是1，以此类推。 使用索引获取列表中的值时，需要使用中括号来访问，在中括号前面加上列表名，中括号内部是元素的索引。 0代表第一个元素的位置，1代表第二个，-1代表倒数第一个，-2代表倒数第二个 使用 len() 函数，可以查看列表里面有多少个元素 在python中，列表的操作是非常的灵活的，我们可以向其中添加或删除元素。 添加使用 list.append() 函数 list.append() 函数是将元素插入到列表的末尾，当我们想在特定位置插入元素时可以使用 list.insert() 函数 list.insert() 函数接受两个参数，第一个参数是插入位置，第二个参数是要插入的元素。 需要注意的是，在使用append和insert时，必须在前面注明要操作的列表。就像上面的例子，我们要操作classmates这个列表，所以必须写成 classmates.append() 或 classmates.insert() ，如果不这么写，计算机就不知道你要往哪个列表中加入元素。 没有特殊情况的话，推荐使用append()函数添加元素，因为使用append的时候，元素默认加在列表尾部，不会造成其他元素索引值的改变。如果使用insert的话，就像上面的insert(1,'Tom')，在位置1插入'Tom'后，Tom后面所有的元素，索引值都加了一个1，列表中元素越多，受影响的程度越大，因此使用append()函数要比insert()函数更快。 删除列表中元素的方法有三种 del后面需要用索引的方式表明要删除的元素，也就是上面的例子，names[1]代表names中的第二个元素，使用del即可删除 list.pop() 函数与del差不多，都是使用索引值进行删除，只不过写法不同。 我们可以发现，执行 names.pop(1) 后，python shell打印出了第二个元素的值，也就是我们要删除的那个值，这是因为 pop() 这个函数，是有返回值的，有时候我们需要使用这个值，这个时候就可以用变量存起来。 这样我们就可以通过调用a而使用刚才删掉的元素了。 list.remove() 函数的作用是删除第一个匹配的元素，上面的例子中，names这个列表里面，有两个'Bob'，remove函数只删除了第一个'Bob'。这就是 list.remove() 函数的特点。 有时候我们想使用列表的前10个元素，或者前n个元素，这时候就应该使用列表的切片。 切片和索引类似，都是使用中括号，区别是，索引中的中括号里面只有一个数，而切片不同。切片是切割列表，形成切割下来的部分形成新的列表。 切片： list[start:end:[step=1]] ，这就是切片的表达式，要求start和end两者必须有一个，step不是可以不指定，不指定的时候默认为1。 切片该怎么理解呢，start就是开始的位置，end就是结束的位置。切片有个特点是“取前不取后”，看上面那个例子可以发现，1作为start，3作为end，1代表第二个元素，3代表第四个元素，列表切片的时候，是不取后面的那个数字对应的元素的，也就是不取第四个元素，所以names[1:3]只取了第二个元素和第三个元素，这就是所谓的取前不取后。 再看下一个例子。 当不指定start或者end的时候，start默认为0，end默认为最后一个元素的索引值+1，因为“取前不取后”，要想取到最后一个元素，必须加个1才行。 上例中，用 len(numbers) 表示了最后一个元素的索引值，因为索引值从0开始，最后一个元素的索引值一定是列表内元素个数-1，根据“取前不取后”，在end位置上的数字应该+1，所以最后就等于 len(numbers) 了。 当不设定start和end的时候，就默认取所有的元素了。 当加入step，这个选项后，step代表步长，默认为1，设定成2的时候，就是隔一个取一个，设定成3时就是隔两个取一个。 上例中，第一个切片，start和end均未设定，因此从第一个元素开始，隔一个取一个，得到了所有奇数位置的元素。 第二个切片，start设定为了1，因此取了所有偶数位置的元素。 3在列表中，0不在列表中，所以 3 in a 是True，而 0 in a 是False 更多关于列表的信息可以通过使用 help(list) 查看帮助文档。㈦ Python3 & 基本数据类型（一）
Python提供的基本数据类型：数值(整型、浮点型、复数、布尔型等)、字符串、列表、元组、字典、集合等，将它们简单分类如下：
通常被称为整型，数值为正或者负，不带小数点。
Python 3的整型可以当做Long类型使用，所以Python 3没有
Python 2的Long类型。
Python 初始化的时候会自动建立一个小整数对象池，方便我们调用，避免后期重复生成！这是一个包含 262个指向整数对象的指针数组，范围是 -5 到 256 。
Python的浮点数就是数学中的小数，类似C语言中的double。
浮点数 也就是小数，如 1.23 ， 3.14 ， -9.01 等等。但是对于很大或很小的浮点数，一般用科学计数法表示，把10用e替代， 1.23x10^9 就是 1.23e9 ，或者 12.3e8 ， 0.000012 可以写成1.2e-5 等等。
复数 由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点。
对 与 错 、 0 和 1 、 正 与 反 ，都是传统意义上的布尔类型。
但在Python语言中，布尔类型只有两个值， True 与 False 。请注意，是英文单词的对与错，并且首字母要大写。
在Python中，0、0.0、-0.0、None、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了 nonzero ()或 len ()方法且方法返回0或False，则其实例也被当作False，其他对象均为True
布尔值还可以用and、or和not运算。
1)、and 运算是 与 运算，只有所有都为 True ， and 运算的结果才是 True ;
2)、or 运算是 或 运算，只要其中有一个为 True ， or 运算结果就是 True ;
3)、not 运算是 非 运算，它是单目运算符，把 True 变成 False，False 变成 True。
例如：
由以上案例可以看出，在做四则运算的时候，明显把 True 看做 1 ， False 看做 0 。
4）空值
空值不是布尔类型，只不过和布尔关系比较紧密。
空值是Python里一个特殊的值，用 None 表示（首字母大写）。None不能理解为0，因为0是整数类型，而None是一个特殊的值。None也不是布尔类型，而是NoneType。
在某些特定的情况下，需要对数字的类型进行转换。
Python提供了内置的数据类型转换函数：
int(x) 将x转换为一个整数。如果x是一个浮点数，则截取小数部分。
float(x) 将x转换成一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y)： 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。
Python字符串即可以用单引号也可以用双引号括起来，甚至还可以用三引号括起来，字符串是以''或""括起来的任意文本。
例如：'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
字符串中包括特殊字符，可以用转义字符来标识
但是字符串里面如果有很多字符都需要转义，就需要加很多，为了简化，Python还允许用r''表示''内部的字符串默认不转义
例如：
print r'\ \' #输出：\ \
字符串的一些常见操作
切⽚是指对操作的对象截取其中⼀部分的操作
语法：序列[开始位置下标:结束位置下标:步⻓]
a. 不包含结束位置下标对应的数据， 正负整数均可；
b. 步⻓是选取间隔，正负整数均可，默认步⻓为1。
find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。
index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。
rfind()： 和find()功能相同，但查找⽅向为右侧开始。
rindex()：和index()功能相同，但查找⽅向为右侧开始。
count()：返回某个⼦串在字符串中出现的次数。
replace()：替换
split()：按照指定字符分割字符串。
join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。
capitalize()：将字符串第⼀个字符转换成⼤写。
title()：将字符串每个单词⾸字⺟转换成⼤写。
lower()：将字符串中⼤写转⼩写。
upper()：将字符串中⼩写转⼤写。
lstrip()：删除字符串左侧空⽩字符。
rstrip()：删除字符串右侧空⽩字符。
strip()：删除字符串两侧空⽩字符。
ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串。
rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和
ljust()相同。
center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语
法和ljust()相同。
所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。
startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开
始和结束位置下标，则在指定范围内检查。
endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开
始和结束位置下标，则在指定范围内检查。
isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回
False。
㈧ python数据类型（集合）
1.集合（set）是一个无序不重复元素的序列(意思是有重复的会自动删除,每次打印元素的位置不一定)
2.基本功能是进行成员关系测试和删除重复元素
3.可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
4.因为set存储的是无序集合，所以我们没法通过索引来访问。访问 set中的某个元素实际上就是判断一个元素是否在set中。
1.创建集合
s=set()#创建一个空集合
s1={1,2,3,'a','python'}
2.删除重复的元素
集合是一个无序不重复元素的序列(意思是有重复的会自动删除,每次打印元素的位置不一定)
3.成员关系测试(检测某个成员是否在集合中)
案例:从终端输入5位数,以空格隔开,把这5位数存入列表中,剔除重复的数据,打印出来
#提示,列表转集合,集合转列表
a=input("请输入5位数字:")
mylist=a.split()
print(mylist)
b=set(mylist)
c=list(b)
print(c)
4.集合常用操作
1.添加元素
2.删除元素
3.删除整个集合
4.获取集合的长度
5.不支持改元素
集合操作-添加元素
格式:
集合.add(元素)
格式:
集合.update(元素)
区别:
add不能添加列表,update可以
update是将字符串中的拆分成字符进行追加
add，是当做整体追加在集合中
#案例:从终端输入一个数字就加入集合中,然后打印,又输入一个数字,然后打印,直到输入-1,退出输入
#然后打印最终的集合
ms=set()
while 1:
a=int(input("请输入一个数字:"))
if a==-1:
break
ms.add(a)
print(ms)
print(ms)
#案例:从终端输入一个字符串就加入集合中,然后打印,又输入一个字符串,然后打印,直到输入q,退出输入
#然后打印最终的集合,字符串要分开存储,如输入hello,存储的列表是{'h','e','l','0'}
ms=set()
while 1:
a=input("请输入一个字符串:")
if a=='q':
break
ms.update(a)
print(ms)
print(ms)
集合操作-删除元素及删除整个集合
格式:
集合.remove(元素) # 元素如果不存在会引发KeyError
集合.discard(元素) # 元素如果不存在不发生任何事
集合.pop() # 集合元素是字符串类型时删除随机元素。 集合元素是其他数据类型时，删除左边第一个元素
del 集合名 #删除整个集合
#案例:有集合{1,2,3,'hello','world'},删除全部字符串,然后最左边第一个元素
a={1,2,3,'hello','world'}
a.discard("hello")
a.discard("world")
a.pop()
print(a)
集合操作-获取集合的长度
格式:
len(集合名)
#案例:有集合{1,2,3,4,'hello','a'},保留1个元素,其他的删除,假如元素个数不确定
s={1,2,3,4,'hello','a'}
for i in range(len(s)-1):
s.pop()
print(s)
集合的集运算
集合的交集,并集,差集,对称差集的运算
{1,2,3,4}交集{4,5,6,7} -->4 交集(&)
{1,2,3,4}并集{4,5,6,7} ->1,2,3,4,5,6,7 并集(|)
{1,2,3,4}差集{4,5,6,7} ->1,2,3 差集(-)
{1,2,3,4}对称差集{4,5,6,7}->1,2,3,5,6,7 4同时出现在两个集合中,不选它 对称差集(^)
#案例:使用花括号和set创建各一个集合,然后对集合进行交、并、差、对称差运算
s={1,2,3,4,5,6}
s1=set([6,7,8,9,10])
print(s&s1)
print(s|s1)
print(s-s1)
print(s^s1)
㈨ 一文搞懂python数据类型和结构
每次python从入门到精通都是从头开始看，做这个学习笔记主要是为了让自己可以省去学习数据类型和结构那几章的时间，所以“偷懒”可以促进生产力发展......
分别是： 整数型、浮点型、复数、常量、布尔型、字符串 。其中复数基本不会使用到，可以不用太关注
分别是 列表、字典、集合和元组 ，其中最常见并且工作中经常使用到的就是列表和字段，其他两个不常见。
02、字典
列表之外，字典可能是python中用的也比较多的数据结构了，由于字典的底层应用哈希映射，所以要求字典的所有key必须是不可变元素（可哈希对象），增删改查操作一般都能实现O(1)复杂度，是低复杂度的必备数据结构。
03、集合
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合操作可能最常见于用于对列表去重，它的最大特性是各元素仅保留1次，底层也是应用了哈希函数，所以在集合中查找元素一般也可实现O(1)复杂度，同时集合的嵌套元素也要求是不可变类型（可哈希对象）
add：在集合中增加一个元素，如果元素已存在，则无实际操作
pop：不接受任何参数，堪称是最神秘的操作，不同于列表的从尾端删除、字典的指定键删除，集合的pop操作看似是"随机"删除。但实际上是按照加入集合的先后顺序，删除"最早"加入的元素
除了与列表和字典中类似的增删改操作外，集合还支持数学概念下的集合操作，如交集、并集、差集等。
04、元组
如果说列表、字典和集合都有其各自擅长应用场景的话，那么元组可能是最没有存在感的数据结构：它接口有限、功能单一，而且是不可变类型。一般而言，用元组解决的问题都可以用列表实现。但使用用元组时，更多在于暗示该序列为不可变类型。当然，当元组内嵌套子列表时实际上是可以对嵌套的子列表进行更改操作的。
https://github.com/zqkyy/py_basic_structure
有问题可以私信我，欢迎交流！
㈩ 如何利用Python语言对字典数据类型进行各种操作
第一步，声明一个字典tree，赋值name和sale键，并打印字典值
第二步，添加字典键值对，字典是由键值对来构成的，声明一个字典hudi并赋值；再次利用该字典添加一个键值对，然后打印添加后的值
第三步，对添加的键值对进行修改键值，获取age这个键，然后重新赋值，打印修改后的结果
第四步，打印hudi字典，利用del删除字典color键值对，然后打印删除后的结果
第五步，再次打印hudi字典，利用clear()方法删除该字典所有的键值对
第六步，利用pop()方法对字典键值对进行删除，会先打印出删除的键值对！