python-02

python 的数据类型：字符串、列表、字典、元组、集合

一：python当中的索引  index
索引分：正向索引和负向索引  正向索引是从0开始，负向索引是从-1开始
str1='abcdef'
print(str1[1])             #打印结果：b
print(str1[5])             #打印结果：f
print(str1[6])              #打印结果：索引越界报错  string index out of range
print(str1[-1])             #打印结果：f
print(str1[-4])              #打印结果：c

二：python当中的切片
[start_index:end_index:step]   ==>[开始索引:结束索引:步长值]
包含开始索引，不包含结束索引
step如果不写默认值是1，step如果为正数则从左往右取，step如果为负数则从右往左取
step为1挨个取，为2隔一个取，为3隔两个取
str1='abcdefg'
print(str1[2:3])      #打印结果：c
print(str1[4:8])       #打印结果：efg
print(str1[:4])        #打印结果：abcd    开始索引没有默认为0
print(str1[1:8:3])      #打印结果：be
print(str1[-6:-2])       #打印结果：bcde
print(str1[-2:-6])       #打印结果为：空    开始索引不能大于结束索引
print(str1[8:4])         #打印结果为：空    开始索引不能大于结束索引
print(str1[-2:-6:-1])      #打印结果为：fedc
print(str1[::2])           #打印结果为：aceg  开始索引跟结束索引都不写代表取所有元素
print(str1[::-2])          #打印结果为：geca
print(str1[::-1])           #打印结果为：gfedcba  切片反转，就是切完之后的元素位置进行颠倒

list1=['duoceshi',1,2,5,'banan31ban','dcs31',15,18,30]
print(list1[5]) # 1、取dcs31元素
print(list1[5:6])
print(list1[7:]) # 2、取18,30元素
print(list1[::-1]) # 3、列表元素进行颠倒
print(list1[-2:-9:-6]) # 4、取18，1元素
print(list1[-3:-6:-1]) # 5、取15、dcs31、baoan31ban
print(list1[:7:3]) # 6、取duoceshi、5、15


整型、浮点型
num1=1234
num2=3.1415926
print(num1,type(num1))
print(float(num1),type(float(num1)))     #利用float方法将整型转化为浮点型

print(num2,type(num2))
print(int(num2),type(int(num2)))          #利用int方法将浮点型转化为整型，只取整数部分

三：字符串常用函数
str1='baoan31ban'
str2='user_name'

print(str1.capitalize())     #首字母大写
print(str1.title())          #除首字母外的其他字符后的首字母也大写
print(str2.capitalize())
print(str2.title())
print(str1[3:5].capitalize())   #利用切片截取一部分元素进行首字母大写  输出结果：An
print(str1[:3].capitalize()+str1[3:7].capitalize()+str1[7:].capitalize())      #利用切片截取一部分元素首字母大写然后进行拼接，输出结果：BaoAn31Ban

print(str1.istitle())          #判断序列中非字母隔开的字符是不是首字母大写，是返回true，不是返回false

print(str1.count('a'))         #统计序列中指定字符出现的次数  3
print(str1.count('bao'))

print('?'.join(str1))            #在序列中的元素用问号拼接一起  输出结果：b?a?o?a?n?3?1?b?a?n
print(''.join(str1))             #在序列中的元素用无字符拼接一起，输出结果：baoan31ban

str1='baoan31ban'
print(str1.split('a'))    #以指定的分割符去分割序列元素，结果返回列表的数据类型['b', 'o', 'n31b', 'n']

str2='ababababbhhhbbab'
print(str2.strip('ab'))       #循环匹配删除以指定的字符开头或者结尾的元素，删除含有a和b  结果输出：hhh
print(str2.lstrip('ab'))      #循环匹配删除以指定的字符开头的元素，删除含有a和b  结果输出：hhhbbab
print(str2.rstrip('ab'))      #循环匹配删除以指定的字符结尾的元素，删除含有a和b  结果输出：ababababbhhh
print(str1.startswith('b'))    #判断序列是否以指定的字符开头，返回布尔值   结果：True
print(str1.startswith('bao'))
print(str1.endswith('n'))       #判断序列是否以指定的字符结尾，返回布尔值   结果：True

a=input('请输入你的姓氏：')
if  a.startswith('李'):
    print('天选之子')
else:
    print('终止交易')

print(str1.find('a'))        #从左往右查询第一个匹配到的指定字符对应的正向索引的值   输出结果：1
print(str1.rfind('a'))       #从右往左查询第一个匹配到的指定字符对应的正向索引的值    输出结果：8
print(str1.replace('baoan','longgang'))    #替换  replace（'旧值'，'新值'） 输出结果：longgang31ban
print(str1.replace('b','k',1))         #替换  replace（'旧值'，'新值'，替换次数）   输出结果：kaoan31ban

str1='baoan31ban'
str2='BAOAN31BAN'
print(str1.upper())          #将所有的元素变大写  输出结果：BAOAN31BAN
print(str2.lower())            #将所有的元素变小写  输出结果：baoan31ban
print(str2.isupper())          #判断序列中元素是否都是大写  输出结果：True
print(str1.islower())          #判断序列中元素是否都是小写  输出结果：True

请输出一个字母，如果输入字母是大写就直接输出，如果输入字母不是大写就把它变成大写输出
a=input('请输入一个字母：')
if  a.isupper():               #如果输入的字母是大写
    print(a)
else:
    a=a.upper()
    print(a)

print(str1.isalnum())       #判断序列中的元素是否都是数字或者字母或者数字与字母的组合，返回布尔值：True
print(str1.isalpha())        #判断序列中的元素是否是纯字母，返回布尔值：False
print(str1.isdigit())        #判断序列中的元素是否是纯数字，返回布尔值：False

将字符串hello、baoan31ban 处理成HelloBaoAn31Ban
str1='hello,baoan31ban'
str2=str1[:5].capitalize()
str3=str1[6:9].capitalize()
str4=str1[9:13].capitalize()
str5=str1[13:].capitalize()
print(str2+str3+str4+str5)


四：数据类型===列表  list
1.定义：用中括号表示[]
list1=[1,2,'dcs31','test',[3,5,'baoan31'],'宝安31班']       #列表中的元素可以是任何数据类型
print(list1,type(list1))

2.利用list方法转化
str1='baoan31ban'
print(str1.split('*'))                  #输出结果：['baoan31ban']
print(list(str1),type(list(str1)))    #['b', 'a', 'o', 'a', 'n', '3', '1', 'b', 'a', 'n'] <class 'list'>

1. 列表切片
   list1=['dcs31','baoan31',18,19,'test']
   print(list1[1:])                      #['baoan31', 18, 19, 'test']
   
   4.列表索引
   print(list1[-1])                     #test
   
   5.列表中的函数
   5-1  append 函数===末尾添加
   list1=['dcs31','baoan31',18,19,'test']
   list1.append('宝安31班')
   print(list1)             #输出结果：['dcs31', 'baoan31', 18, 19, 'test', '宝安31班']
   
   list2=[]
   list2.append('baoan31ban')
   print(list2)                          #['baoan31ban']
   
   5-2 extend函数==拼接
   5-2-1 列表拼接列表
   list1=['dcs31','baoan31',18,19,'test']
   list2=['a','b','c','d']
   list1.extend(list2)
   list2.extend(list1)
   print(list1)                  #['dcs31', 'baoan31', 18, 19, 'test', 'a', 'b', 'c', 'd']
   print(list2)                #['a', 'b', 'c', 'd', 'dcs31', 'baoan31', 18, 19, 'test']
   
   5-2-2  列表拼接字符串
   list1=['dcs31','baoan31',18,19,'test']
   str1='duoceshi'
   list2=str1.split('?')    #split输入对应不存在在字符串中的字符直接转化为一个列表显示一个元素
   list1.extend(str1)
   print(list1)        #['dcs31', 'baoan31', 18, 19, 'test', 'd', 'u', 'o', 'c', 'e', 's', 'h', 'i']
   print(list2)        #['duoceshi']

list1.extend(list2)
print(list1)               #['dcs31', 'baoan31', 18, 19, 'test', 'duoceshi']
str1.extend(list1)       #不可以，extend是列表的拼接函数，不是字符串的函数
print(str1)

5-3   insert函数===插入   insert(索引的值，’内容')
list1=['dcs31','baoan31',18,19,'test']
list1.insert(1,'kk')
print(list1)                 #['dcs31', 'kk', 'baoan31', 18, 19, 'test']
list1.insert(9,'kk')          #如果指定的所有位置超过范围会在末尾写入
print(list1)                #['dcs31', 'baoan31', 18, 19, 'test', 'kk']

list1[0]='duoceshi31'       #通过索引的位置对指定元素进行修改（重新赋值）
print(list1)                 #['duoceshi31', 'baoan31', 18, 19, 'test']

5-4  remove函数===移除，删除
list1=['dcs31','baoan31','test',18,19,'test']
list1.remove(19)
print(list1)              #['dcs31', 'baoan31', 18, 'test']
list1.remove('test')       #当前序列中有重复的元素，删除的是第一个匹配到的
print(list1)              #['dcs31', 'baoan31', 18, 19, 'test']
list1.remove('aa')  #当删除的元素不在列表中，直接报错： list.remove(x): x not in list
print(list1)

5-5 del 函数===删除
list1=['dcs31','baoan31','test',18,19,'test']
del list1[2]             #通过索引删除元素
print(list1)             #['dcs31', 'baoan31', 18, 19, 'test']
del list1
print(list1)             #删除成功后打印报错：name 'list1' is not defined

5-6 pop函数===删除 ，可以返回被删除的元素
list1=['dcs31','baoan31','test',18,19,'test']
list1.pop(0)            #通过索引删除
print(list1)            #['baoan31', 'test', 18, 19, 'test']
print(list1.pop(0))       #打印被删除元素：dcs31

list1.pop(9)
print(list1)             #输出结果：索引不在范围内

5-7 index 函数===查看匹配到的第一个元素的索引
list1=['dcs31','baoan31','test',18,19,'test']
print(list1.index('test'))         #   2
print(list1.index(18))               #   3
print(list1[1:].index(18))           #指定列标中元素显示指定索引   2

5-8 sort函数===实现列表升序排序（永久排序）从小到大排序（排序规则，数据类型不同不能一起排序）
list1=[1,5,3,7,8,4,9,19]
list2=['dcs31','baoan31','&','18','19','Test','多测师']
list1.sort()
print(list1)                #[1, 3, 4, 5, 7, 8, 9, 19]
list2.sort()
print(list2)        #不能排序因为存在不能数据类型 ，如果存在数字用引号表示在列表中那么排序规则：特殊字符》数字》大写》小写》中文   ['&', '18', '19', 'Test', 'baoan31', 'dcs31', '多测师']

5-9 sorted函数 ===》排序从小到大（临时排序）
list1=[1,5,3,7,8,4,9,19]
print(sorted(list1))            #升序排序  输出结果：[1, 3, 4, 5, 7, 8, 9, 19]
list2=sorted(list1)
print(list2[::-1])                  #实现降序排序   输出结果[19, 9, 8, 7, 5, 4, 3, 1]
print(sorted(list1,reverse=True))    #实现降序排序  (reverse=true降序的意思,reverse=false升序)

 输出结果[19, 9, 8, 7, 5, 4, 3, 1]
print(list1)

五：数据类型--元组  tuple
1.定义---用小括号()表示
 tuple1=(1,2,'test','dcs31','baoan31')
 print(tuple1,type(tuple1))               #(1, 2, 'test', 'dcs31', 'baoan31') <class 'tuple'>

2.字符串转元组
 str1='duoceshi31'
 print(tuple(str1),type(tuple(str1)))     #('d', 'u', 'o', 'c', 'e', 's', 'h', 'i', '3', '1') <class 'tuple'>

3.当元组只有一个元素时，不能成为元组，需要在元素后面加逗号
 tuple1=('a')
 print(tuple1,type(tuple1))    #a <class 'str'>

 tuple2=('a',)
 print(tuple2,type(tuple2))     #('a',) <class 'tuple'>

4.元组转列表
 tuple1=(1,2,'test','dcs31','baoan31')
 list1=list(tuple1)
 print(list1)                      #[1, 2, 'test', 'dcs31', 'baoan31']

5.列表转元组
 list1=[1, 2, 'test', 'dcs31', 'baoan31']
 tuple1=tuple(list1)
 print(tuple1)                       #(1, 2, 'test', 'dcs31', 'baoan31')

6.切片和索引操作元组
 tuple1=(1, 2, 'test', 'dcs31', 'baoan31')
 print(tuple1[1:9])                      #(2, 'test', 'dcs31', 'baoan31')
 print(tuple1[1])                        # 2

7.修改元组中的元素
 tuple1=(1, 2, 'test', 'dcs31', 'baoan31')
 tuple1[3]='duoceshi'                     #不能直接改 ，报错
 list1=list(tuple1)                      #将元组转化为列表
 list1[3]='duoceshi'                     #把列表索引为3的元素修改为duoceshi
 tuple1=tuple(list1)                     #把列表转化元组
 print(tuple1)                      #(1, 2, 'test', 'duoceshi', 'baoan31')

8.列表和元组的区别
相同点：
1.都支持切片和索引的操作
2.相互之间可以转化
3.都是python中的一种数据类型，它的元素都可以是任何数据类型

不同点：
1.列表是可变序列（元素可以随意增删改），元组不可变序列（不可以随意增删改）
2.元组可以写保护功能，数据存储方面比较安全
3.如果元组的元素需要该表，需要将元组进行转化为列表，改变后再转化为元组

元组中的aa改成bb
 tuple1=(1,2,3,('test','dcs31','baoan31',['aa','kk']))
 list1=list(tuple1)
 print(list1)                  #[1, 2, 3, ('test', 'dcs31', 'baoan31', ['aa', 'kk'])]
 list1[3][3][0]='bb'
 tuple1=tuple(list1)
 print(tuple1)                   #(1, 2, 3, ('test', 'dcs31', 'baoan31', ['bb', 'kk']))

六：数据类型===字典 dict  以键（key）值（values）对的形式出现
1.定义：用大括号+键值对  直接定义{}
 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 print(dict1,type(dict1))          #{'name': 'xiaocheng', 'age': 18, 'sex': '男'} <class 'dict'>

2.dict方法转化  ===有要求，序列中元素必须要对存在，才能形式键值对
 list1=[['a',1],['b',2]]
 tuple1=(['c',3],['d',4])
 dict1=dict(list1)
 dict2=dict(tuple1)
 print(dict1)                          #{'a': 1, 'b': 2}
 print(dict2)                         #{'c': 3, 'd': 4}

映射：用自己定义的表示代表对应内容
男：1   女：0
订单状态status：1.表示未付款  2.已付款  3.表示已签收
枚举值：用一个变量来对应每个枚举值    月：1-12   日：1-31

3.字典相关函数和特点
3-1；当字典存在相同的键时，会取最后键对应的值，键具有唯一性，值可以不唯一
 dict1={'name':'xiaocheng','age':18,'sex':'男','name':'xiaobao'}
 print(dict1)                   #{'name': 'xiaobao', 'age': 18, 'sex': '男'}

 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 dict1['score']=89                            #添加键值对，当键值对不存在，直接添加
 dict1['name']='lisi'                         #添加键值对，当键值对存在，对键重新赋值
 print(dict1)                                   #{'name': 'lisi', 'age': 18, 'sex': '男'}

3-2：keys()函数，取出字典所有的键
 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 print(dict1.keys())                  #dict_keys(['name', 'age', 'sex'])

3-3:values()函数 ，取出字典所有的值
 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 print(dict1.values())               #dict_values(['xiaocheng', 18, '男'])
 print(dict1['name'])               #以键取值    xiaocheng

3-4:setdefault()函数，往字典添加元素
 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 dict1.setdefault('class','102')             #添加键值对（原键值对不存在---直接添加）
 print(dict1)                               #{'name': 'xiaocheng', 'age': 18, 'sex': '男', 'class': '102'}

 dict1.setdefault('age',21)                   #原键值对存在----操作无效
 print(dict1)                              #{'name': 'xiaocheng', 'age': 18, 'sex': '男'}

 dict1.setdefault('score')                 #原键值不存在（只添加键）---值会用None填充
 print(dict1)                              #{'name': 'xiaocheng', 'age': 18, 'sex': '男', 'score': None}

 a='score'                                  #利用变量的形式进行写入
 b=89
 dict1.setdefault(a,b)
 print(dict1)                               #{'name': 'xiaocheng', 'age': 18, 'sex': '男', 'score': 89}

3-5:del 删除，通过键删除
 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 del dict1['name']                  #删除指定键会同值一起删除
 print(dict1)                      #{'age': 18, 'sex': '男'}

 del dict1                           #删除整个字典
 print(dict1)                        #报错提示dict1字典不存在

3-6:get()函数 通过传入键，得到对应的值====以键取值
 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 dict2=dict1.get('age')
 print(dict2)                    # 18
 print(dict1.get('name'))          # xiaocheng

for 变量 in 序列  ： 遍历语句
 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 for i in dict1:                      #for循环的i变量去遍历字典dict1
    # print(dict1[i])                #打印变量所有的值
    # print(i,dict1[i])                #打印变量和变量对应的值

 for j in dict1:
    # print(dict1.get(j))
    # print(j,dict1.get(j))

3-7:items()函数  配合for循环，用两个变量分别遍历键和值
 dict1={'name':'xiaocheng','age':18,'sex':'男'}
 for x,y in dict1.items():     #利用for循环的x,y两个变量分别遍历键和值
     print(x,y)                  #name xiaocheng   age 18  sex 男

3-8:pop()函数==删除指定键，会返回对应值
 dict1={'name':'xiaocheng','age':18,'sex':'男','class':102}
 print(dict1.pop('class'))            #返回对应值
 print(dict1.pop())                     #不给参数会报错
 print(dict1)

3-9：popitem()函数   删除字典末尾的键值对，并以元组的数据类型返回
 dict1={'name':'xiaocheng','age':18,'sex':'男','class':102}
 print(dict1.popitem())              #('class', 102)   ===返回的数据是以元组的形式
 print(dict1)                        #{'name': 'xiaocheng', 'age': 18, 'sex': '男'}

3-10:clear()函数  清空字典中的元素，剩下一个空字典
 dict1={'name':'xiaocheng','age':18,'sex':'男','class':102}
 dict1.clear()                     #清空字典
 print(dict1)                      #{}

3-11:fromkeys()函数 ，生成一个新字典
 print({}.fromkeys(['name']))        #{'name': None}  单独给键，不给值，值会用None补充
 print({}.fromkeys(['name','xiaocheng'],'lisi'))     #{'name': 'lisi', 'xiaocheng': 'lisi'} 多个键单个值，多个键对应一个值
 print({}.fromkeys(['name','age'],['lisi',32]))   #{'name': ['lisi', 32], 'age': ['lisi', 32]} 多个键，单个值（一个序列，值不拆分）

3-12：__contains__()函数字典中有没有指定键，返回布尔值
 dict1={'name':'xiaocheng','age':18,'sex':'男','class':102}
 print(dict1.__contains__('name'))     #True  判断字典中有没有键  有返回True，没有返回false
 print(dict1.__contains__('score'))        #False

3-13:update()函数  更新，用一个字段更新另一个字典
 dict1={'name':'xiaocheng','age':18,'sex':'男','class':102}
 dict2={'name':'lisi'}
 dict3={'score':88}
 dict1.update(dict2)          #字典2的键值对在字典1中存在，将键对应值进行重新赋值
 dict2.update(dict3)          #字典2的键值对不存在字典3中，直接添加
 dict2.update(dict1)          #字典1的键值对在字典2中存在，将键对应值进行重新赋值
 print(dict1)
 print(dict2)                      #{'name': 'lisi', 'score': 88}


七：数据类型==集合  set可变集合 、frozenset 不可变集合
1.定义：使用大括号{}定义
 set1={1,2,'kk'}
 print(set1,type(set1))                #{'kk', 1, 2} <class 'set'>

2.集合转化
 tuple1=(1,2,3,4)
 list1=['aa','bb',4,6,8]
 set2=set(tuple1)                   #把元组转化可变集合
 set1=set(list1)                    #把列表转化可变集合
 print(set1,type(set1))              #{4, 6, 8, 'bb', 'aa'} <class 'set'>
 print(set2,type(set2))              #{1, 2, 3, 4} <class 'set'>

 frozenset1=frozenset(list1)          #列表转化为不可变集合
 print(frozenset1,type(frozenset1))   #frozenset({4, 'aa', 6, 8, 'bb'}) <class 'frozenset'>

 frozenset2=frozenset(tuple1)           #把元组转化不可变集合
 print(frozenset2,type(frozenset2))     #frozenset({1, 2, 3, 4}) <class 'frozenset'>

3.集合的特点
3-1：无序性----集合中混合元素
3-2：有序列----集合中纯数字
3-3：去重和排序
 list1=[9,6,2,5,12,7,18,20,11,20,20]
 set1=set(list1)
 print(set1)                     #{2, 5, 6, 7, 9, 11, 12, 18, 20}  具有去重和排序的功能

4.集合相关函数
4-1：可变集合set
4-1-1：add，update，remove，pop，clear
 list1=['aa','bb',4,6,8]
 set1=set(list1)               #转化为可变集合
 set1.add('kk')             #往集合中添加单个元素
 print(set1)               #{4, 6, 8, 'aa', 'bb', 'kk'}

 set1.update(['dd','ww'])     #往集合中添加多个元素
 print(set1)                #{4, 6, 8, 'aa', 'ww', 'bb', 'dd'}

 set1.remove('bb')           #指定删除元素
 print(set1)                  #{4, 6, 8, 'aa'}

 set1.pop()                   #随机删除一个元素
 print(set1)                  #{4, 6, 8, 'bb'}

 set1.clear()                  #清空
 print(set1)                   #set()

4-2:不可变集合frozenset
 list1=['aa','bb',4,6,8]
 frozenset1=frozenset(list1)
 frozenset1.add('kkk')           #不可变集合没有add这个函数
 print(frozenset1)                 #直接报错
 frozenset1.clear()
 print(frozenset1)

不可变集合不能进行增删改操作
可变序列：字符串、列表、字典、可变集合
不可变序列：元组、数字、不可变集合