Python学习笔记二——数据类型及数据操作

概要 ：

基本语法 

             输出格式、 变量 、注释

数据类型

            Numbers (数字)、String (字符串)、List (列表)、Tuple(元组)、Cictionary(字典)  及各个数据类型的常用方法和内置函数   、多维数组等         

数据操作

       切片操作 、回文算法

 

 

基本语法 -

输出格式 ：

Python的输出语法和Swift的输出一样

1 # 输出
2 print("Hello Python")

 

注释 ：

Python中单行注释采用 # 开头。

python中多行注释使用三个单引号 ''' 或三个双引号 """

 

变量 ：

Python中的变量不需要声明，变量的赋值操作既是变量声明和定义的过程。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

Python允许你同时为多个变量赋值, 也可以为多个对象指定多个变量。例如：

1 a = b = c = 1 
2 
3 # 多变量赋值
4 a, b, c = 1, 2, "jun"

 

标准数据类型

有五个标准的数据类型：

Numbers (数字)

String (字符串)

List (列表)

Tuple(元组)

Cictionary(字典)

 

Number（数字）

Number是不可被改变的数据类型, 当你指定一个值时，Number对象就会被创建

Python支持四种不同的数值类型：

                               int （有符号整型）

                               long （长整型[也可以代表八进制和十六进制]）

                               float （浮点型）

                              complex （复数）

                          复数: 和数学中的复数含义一样, 复数由实数部分和虚数部分构成，可以用a+bj, 或者complex（a,b）表示， 复数的实部a和虚部b都是浮点型

 

字符串

• 字符串或串(String)是由数字、字母、下划线组成的一串字符
• Swift中的字符串一样, 每一个字符都有一个与之对应的索引
• Python的字串列表有2种取值顺序:
• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头
• 获取某一部分字符串的格式: [头下标:尾下标]

 

 1     字符串的常用方法
 2         s='aNc'
 3         q='1+2+3\n1+2+3+4'
 4         a='mysql is is db'
 5         s.find('z')) # 找不存在的元素，find会返回-1
 6         s.index('z')   #  找不存在的元素，index报错
 7         s.count('z')  # 计数
 8         a.rfind('db'))#返回最右边字符的下标
 9         s.upper()   # #变成大写
10         s.lower()   #变成小写
11         s.swapcase())#大小写反转
12         s.capitalize() #首字母大写
13         s.split(',')   # 以，位分隔符，返回list
14         q.splitlines()#按照换行符分割
15         s.strip('abc') #去除“abc”
16         s.lstrip()   ##默认去掉左边的空格和换行
17         s.rstrip()    ##默认去掉右边的空格和换行
18         s.replace('old','new')  # 替换
19         s.endswith('xxx.mp3')     #判断时候xxx.mp3结尾
20         s.startswith('186')    #判断时候186开头
21         s1=','.join(list)    #1、把list变成了字符串 2、把list里面每一个元素用逗号连接起来                                             username,user2,user3
22         print('+'.join(['hehe', 'haha', 'ee']))  # 拼接字符串     hehe+haha+ee
23         s.isdigits()  ##判断是否为正整数
24         s.isalpha() #是否是英文字母
25         s.isalnum()  #是否包含数字和字母
26         s.zfill(5)  # 位数不足5位时，自动补零
27         s.isidentifier())#是否是一个合法的变量名
28         s.istitle())#是不是一个标题，判断首字母是否大写
29         s.isidentifier())#是否是一个合法的变量名
30         a.rfind('is')#返回最右边字符的下标

 

 

 

 

 1 # 字符串
 2 str = 'Hello Python'
 3 
 4 # 1. 输出完整字符串
 5 print("完整字符串--" + str)
 6 # 结果输出:
 7 
 8 # 2. 输出第一个字符
 9 print("第一个字符--" + str[0])
10 
11 # 3. 输出第三到七个字符
12 print("第3-7个字符--" + str[2:6])
13 
14 # 4. 输出低2个字符开始的所有字符
15 print("第2个开始的所有字符--" + str[1:])
16 
17 # 5. 拼接字符串
18 # 像上面一样, 字符串用 `+`拼接
19 print("拼接--" + str)
20 
21 # 6. 输出3次
22 # `*` 表示重复操作, 需要重复操作几次, 后面跟上次数即可
23 print(str * 3)
24 
25 # 7. 输出最后一个字符
26 print("最后一个字符--" + str[-1])
27 
28 # 8. 输出倒数第二个字符
29 print("倒数第二个字符--" + str[-2])

# 输出 结果  

 1 
 2 完整字符串--Hello Python
 3 第一个字符--H
 4 第3-7个字符--llo 
 5 第2个开始的所有字符--ello Python
 6 拼接--Hello Python
 7 Hello PythonHello PythonHello Python
 8 最后一个字符--n
 9 倒数第二个字符--o
10 

一些方法：

 1 password='jpg 12345456789 .jpg ABCDE'
 2 print(password)    # 输出结果 ：jpg 12345456789 .jpg ABCDE   new_password = password.strip()  # 默认去掉字符串两边的空格

new_password = password.strip('\n')  # 默认去掉字符串两边换行符

 3 new_password = password.strip('.jpg') # 默认去掉字符串两边的指定去掉字符串  4 print(password.lstrip()) # 左边的  5 print(password.rstrip()) # 右边的  6 print('password',password)  7 print('newpassword',new_password)  8 print(password.upper()) # 转成大写的  9 print(password.lower()) # 转成小写的 10 print(password.capitalize()) # 吧首字母改成大写的 11 print(password.count('jpg')) # 计算指定字符的在字符串中的次数 12 print(password.replace('爱玲','上山打老虎')) # 替换字符串

1 filename = 'a.mp4'
2 age=18
3 print(filename.endswith('.mp3'))  # 判断是否以xx结尾  # 输出 ： False
4 print(filename.startswith('18'))  # 判断是否以开头    # 输出 ：True
5 print('{name},{age}'.format(name='hhh',age=age))  # 字符串格式化   # 输出 ： hhh，18

1 names = '小军 海龙 杨帆     爱玲'
2 print(names.replace(' ',''))  # 把name中的空格替换掉
3 print(names.split(' '))        # 以 空格 作为分割符 进行分割，分割后的每个元素组成一个list
4 # 1、是把字符串变成list
5 # 2、以某个字符串分割，分割之后的是list里面的每一个元素

 

List（列表）

• List（列表） 是 Python 中使用最频繁的数据类型, 和C语言中的数组一样, 语法操作和上述字符串类似
• 列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。
• 列表用[ ]标识。是python最通用的复合数据类型
列表中的值得分割也可以用到变量[头下标:尾下标]，就可以截取相应的列表   （下标=索引=角标）
• 从左到右索引默认0开始的
• 从右到左索引默认-1开始
• 下标可以为空表示取到头或尾。
• 加号（+）是列表连接运算符，星号（*）是重复操作

 1 # List 列表
 2 list1 = [12, 34, 3.14, 5.3, 'titan']
 3 list2 = [10, 'jun']
 4 
 5 # 1.完整列表
 6 print(list1)
 7 
 8 # 2.列表第一个元素
 9 print(list1[0])
10 
11 # 3.获取第2-3个元素
12 print(list1[1:2])
13 
14 # 4.获取第三个到最后的所有元素
15 print(list1[2:])
16 
17 # 5.获取最后一个元素
18 print(list1[-1])
19 
20 # 6.获取倒数第二个元素
21 print(list1[-2])
22 
23 # 7.获取最后三个元素
24 print(list1[-3:-1])
25 
26 # 8.合并列表
27 print(list1 + list2)
28 
29 # 9.重复操作两次
30 print(list2 * 2)

 

 

1、增加列表元素：A、list.append()B、list.insert()

1 # 增加列表元素
2 stu_name = ['哈华','呢呢','心',1,1.5]
3 print(stu_name)
4 stu_name.append('小月')  # 在list的末尾添加一个元素
5 stu_name.insert(0,'小军')  # 指定位置添加元素
6 stu_name.insert(0,'小军')  # 指定位置再添加元素
7 print('修改之后的',stu_name)

 输出结果 ：

1 ['哈华', '呢呢', '心', 1, 1.5]
2 修改之后的 ['小军', '小军', '哈华', '呢呢', '心', 1, 1.5, '小月']

 

 

2、修改列表元素

1 # 修改列表元素
2 stu_name = ['哈华','呢呢','心',1,1.5,'强']
3 stu_name[5]='花花'
4 print('修改之后的',stu_name) 
5 
6 # 输出结果 ：
7 
8 修改之后的 ['哈华', '呢呢', '心', 1, 1.5, '花花']

 

 

3、删除列表元素 ：A、list.pop()

#没有下标，删除最后一个元素

若删除指定下标的元素,删除不存在的元素会报错

B、del list[1] :

# 下标、索引、如果是正数就从左边开始算起，如果是负数，则从后面开始数起，倒序

C、list.remove('')   #删除指定的元素，如果有一样的元素，只会删除第一个

# 删
stu_name = ['哈华','呢呢','心',1,1.5,'强']

stu_name.pop()  # 删除最后一个元素
stu_name.pop(4)  # 删除指定下标的元素
print("删除后：",stu_name)

# 输出结果 ：

删除后： ['哈华', '呢呢', '心', 1]

 1 # 删
 2 stu_name = ['哈华','呢呢','心',1,1.5,'强' ,'小军']
 3 
 4 # stu_name.pop()  # 删除最后一个元素
 5 # stu_name.pop(4)  # 删除指定下标的元素
 6 # print("删除后：",stu_name)
 7 stu_name.append('小军')  # 先增加一个小军
 8 print(stu_name)
 9 stu_name.remove('小军')  # 删除指定的元素，如果有一样的元素，只会删除第一个
10 stu_name.pop(1)  # 删除指定下标的元素,删除不存在的元素会报错
11 print(stu_name)
12 del stu_name[-1]  # 下标、索引、如果是正数就从左边开始算起，如果是负数，则从后面开始数起，倒序
13 print(stu_name)
14 
15 
16 #输出结果 ：
17 ['哈华', '呢呢', '心', 1, 1.5, '强', '小军', '小军']
18 ['哈华', '心', 1, 1.5, '强', '小军']
19 ['哈华', '心', 1, 1.5, '强']

 

 

 

 4、查询列表元素：

 1 #  查
 2 my_list = ['小黑','小白',1,1,2,1.5]
 3 print(my_list[-1])
 4 print(my_list[0])
 5 print(my_list.count(5))     # 查询某个元素在list里面出现的次数
 6 print('index方法：',my_list.index(1))     # 查找元素的下标，元素不存在的话，会报错
 7 print('reverse:',my_list.reverse())     # reverse是反转list
 8 print(my_list)
 9 # my_list.clear()#清空整个list
10 # print(my_list)
11 
12 nums =[9.23,9,3,6,1,0]
13 nums.sort() # 排序，升序
14 nums.sort(reverse=True)    # 排序,如果指定了reverse=True，那么就是降序
15 # nums.extend(my_list)#把一个list里面的元素加入进去
16 print(nums)
17 new_list = nums + my_list + stu_name
18 # extend是把列表本身变化了，而直接
19 # 两个列表相加的话，列表本身没有变化，只是相加的结果存在一个新的列表里面
20 print(new_list)
21 print(new_list * 3)    # 复制几个

 

 列表函数和方法 ：

 1 函数表达式                   输出结果                描述
 2 len(list1)                   3                  列表元素个数
 3 max([1, 2, 's'])             s                  返回列表元素的最大值
 4 min([1, 2, 's'])             1                  返回列表元素的最小值
 5 list(('q', 1)             ['q', 1]              将元组转换为列表
 6 list1.append(2)           [1, 2, 3, 2]          在列表末尾添加新的对象
 7 list1.count(2)               2                  统计某个元素在列表中出现的次数
 8 list1.index(3)               2                  从列表中找出某个值第一个匹配项的索引位置
 9 list1.insert(1, 'jun')    [1, 'jun', 2, 3, 2]   将对象插入列表的指定位置
10 list1.remove(3)         [1, 'jun', 2, 2]        移除列表中某个值的第一个匹配项
11 list1.reverse()         [2, 2, 'jun', 1]        对列表的元素进行反向排列
12 list1.sort()            [2, 2, 'jun', 1]         对原列表进行排序, 如果指定参数，则使用比较函数指定的比较函数

 

extend()方法

用于在列表末尾一次性追加另一个序列(元组和列表)中的多个值（用新列表扩展原来的列表）

1 list3 = [12, 'as', 45]
2 list4 = (23, 'ed')
3 list3.extend(list4)
4 print(list3)
5 
6 //输出:
7 [12, 'as', 45, 23, 'ed']

len( )  :  取长度

1 passwords=['123456','123123','7891234','password']
2 print(len(passwords))  # 取长度，也就是list里面元素的个数 
3 
4 # 输出结果 
5 4

 

      多维数组 ：

       

 1 nums1 = [1,2,3]  # 一维数组
 2 nums2 = [1,2,3,[4,56]]  # 二维数组
 3 print(nums2[-1][-1])
 4 
 5 # 多维数组
 6 
 7 nums = [1,2,3,4,['a','b','c','d','e',['一','二','三']],['四','五']]  # 三维数组
 8 nums3 = [1,2,3,4,['a','b','c','d','e',['一','二','三',[1,2,3]]]]  # 四维数组
 9 print(nums[4][5][1])
10 
11 # 输出结果
12 56
13 二

循环List ：

 1 # 循环这个list 
 2 # 原始方式
 3 passwords=['123456','123123','7891234','password']
 4 
 5 count = 0  # 最原始list取值方式，是通过每次计算下标来获取元素的
 6 while count<len(passwords):
 7     s = passwords[count]
 8     print('每次循环的时候',s)
 9     count+=1
10 
11 # 输出结果 ：
12 每次循环的时候 123456
13 每次循环的时候 123123
14 每次循环的时候 7891234
15 每次循环的时候 password
16 
17 
18 
19 #  简单方式 用for循环 
20 passwords=['123456','123123','7891234','password']
21 index = 0
22 for p in passwords:  #  for循环直接循环一个list，那么循环的时候就是每次取它的值
23     passwords[index] = 'abc_'+p
24     index+=1
25 print(passwords)
26 
27 
28 #输出结果：
29 ['abc_123456', 'abc_123123', 'abc_7891234', 'abc_password']

 

元组

• 元组是另一个数据类型(Python中的元组和Swift中的元组类似)
• 元组用”()”标识。内部元素用逗号隔开
• 元素不能二次赋值，相当于只读列表
• 元组也是一个不可变列表，元组不能修改 

 1 # 元组
 2 tuple1 = (12, 34, 3.14, 5.3, 'titan')
 3 tuple2 = (10, 'jun')
 4 
 5 # 1.完整元组
 6 print(tuple1)
 7 
 8 # 2.元组一个元素
 9 print(tuple1[0])
10 
11 # 3.获取第2-3个元素
12 print(tuple1[2:3])
13 
14 # 4.获取第三个到最后的所有元素
15 print(tuple1[2:])
16 
17 # 5.获取最后一个元素
18 print(tuple1[-1])
19 
20 # 6.获取倒数第二个元素
21 print(tuple1[-2])
22 
23 # 7.获取最后三个元素
24 print(tuple1[-3:-1])
25 
26 # 8.合并元组
27 print(tuple1 + tuple2)
28 
29 # 9.重复操作两次
30 print(tuple2 * 2)
31 

元组运算符

 1 # 计算元素个数
 2 print(len((1, 2, 3)))
 3 # 合并元组
 4 tuple1 = (1, 2) + (4, 5)
 5 print(tuple1)
 6 # 重复
 7 tuple2 = ('jun',) * 3
 8 print(tuple2)
 9 # 检测是否包含某元素
10 if (2 in tuple1):
11     print('2在该元组内')
12 else:
13     print('不在元组内')
14 # 遍历元组
15 for x in tuple1:
16     print(x)
17 
18 //输出:
19 3
20 (1, 2, 4, 5)
21 ('jun', 'jun', 'jun')
22 2在该元组内
23 1
24 2
25 4
26 5

元组内置函数

 1 tuple1 = (1, 2, 4, 5) 
 2 # 元组中元素最大值
 3 print(max(tuple1))
 4 # 元组中元素最小值
 5 print(min(tuple1))
 6 # 列表转换为元组
 7 print(tuple(['a', 'd', 'f']))
 8 
 9 //输出:
10 5
11 1
12 ('a', 'd', 'f')
13 
14  # 元组 只有一个字符串元素的时候，一定要加 引号。
15  tuple1.count(‘a’)# 统计某个元素在元组中出现的次数  
16 tuple1.index('a')   #从元组中找出某个值第一个匹配项的索引位置

 

  

 

字典 

• 字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。
• 列表是有序的对象集合，字典是无序的对象集合。
• 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过索引存取。
• 字典用”{ }”标识。字典由索引(key)和它对应的值value组成
• 这里的字典的key值, 不仅仅可以用字符串, 还可以用Number类型

K - V 形式，可循环优点：好取值，速度快 

 1 hailong = {
 2     'name':'hailong',
 3     'sex':'男',
 4     'shengao':'185',
 5     'age':18,
 6     'email':'acb@qq.com',
 7     'addr':'火星',
 8     'id':2
 9 }
10 
11 # for i in hailong:
12 #     print(i)
13 #     if i =='name':
14 #         print(hailong[i])
15  # 无序输出
16 sex
17 age
18 shengao
19 name
20 hailong
21 id
22 email
23 addr
24 
25 
26 for  k,v in hailong.items():     # 字典转换成一个list
27     print(k,v)
28     
29 # 无序输出 
32 email acb@qq.com
33 id 2
34 name hailong
35 sex 男
36 shengao 185
37 addr 火星
38 age 18

 1 # 字典
 2 dict1 = {'name': 'jun', 'age': 18, 'score': 90.98}
 3 dict2 = {'name': 'titan'}
 4 
 5 # 完整字典
 6 print(dict2)
 7 
 8 # 1.修改或添加字典元素
 9 dict2['name'] = 'brother'
10 dict2['age'] = 20
11 dict2[3] = '完美'
12 dict2[0.9] = 0.9
13 print(dict2)
14 
15 # 2.根据键值获取value
16 print(dict1['score'])     #当查询的键不存在的时候，会报错

    print（dict1（get('score')））   #用get方法去查询字典，好处就是当查询的键不存在的时候，不会报错
17 
18 # 3.获取所有的键值
19 print(dict1.keys())
20 
21 # 4.获取所有的value值
22 print(dict1.values())
23 
24 # 5.删除字典元素
25 del dict1['name']
26 print(dict1)
27 
28 # 6.清空字典所有条目
29 dict1.clear()
30 print(dict1)
31 
32 # 7.删除字典/元素

1 #delete
2  dict1.pop('age')  # 删除指定key的值
3  print('删除age',dict1)4  dict1.popitem() #随机删除5  print(dict1)6 
7  del dict1['age'] #del 删除8  print(dict1）

33 dict3 = {2: 3}
34 del dict3
35 # 当该数组呗删除之后, 在调用会报错
36 # print(dict3)#合并字典 :字典合并，字典是没有顺序的，增加字段后位置也是随机放的d1 = {'a': 'A','b':'B'}d2 = {'c':'C'}d1.update(d2)print(d1)print(d2)# 输出{'a': 'A', 'c': 'C', 'b': 'B'}
{'c': 'C'}

 # 字典多层嵌套取值 1 all_stus = {
 2     'xiaojun':
 3     {
 4         'sex': '男',
 5         'shengao': '185',
 6         'age': 18,
 7         'email': 'acb@qq.com',
 8         'addr': '火星',
 9         'id': 1,
10         'cars':['牧马人','911','野马','劳斯莱斯']
11 
12     },
13     'hailong':{
14         'sex': '男',
15         'shengao': '185',
16         'age': 18,
17         'email': 'acb@qq.com',
18         'addr': '火星',
19         'id': 2
20     },
21     'yangfan':{
22         'sex': '男',
23         'shengao': '185',
24         'age': 18,
25         'email': 'acb@qq.com',
26         'addr': '火星',
27         'id': 3,
28         'bags':{
29             'qianbao':['lv','ysl'],
30             'beibao':['coach','abc']
31         }
32     }
33 }
34  all_stus['xiaojun']['cars'].append('五菱宏光') # 添加一个
35  print(all_stus['小军'])  #输出 

1 {'addr': '火星', 'shengao': '185', 'sex': '男', 'age': 18, 'id': 1, 'cars': ['牧马人', '911', '野马', '劳斯莱斯', '五菱宏光'], 'email': 'acb@qq.com'}

36 print(len(all_stus['xiaojun']['cars']))# 输出    5
37 all_stus['yangfan']['sex'] = '女'
38  print(all_stus['yangfan']) # 输出 

1 {'sex': '女', 'email': 'acb@qq.com', 'shengao': '185', 'id': 3, 'addr': '火星', 'bags': {'qianbao': ['lv', 'ysl'], 'beibao': ['coach', 'abc']}, 'age': 18}

39 all_stus['yangfan']['bags']['qianbao'].remove('lv') # 移除lv

print(all_stus['yangfan'])

#输出 

1 {'sex': '男', 'email': 'acb@qq.com', 'addr': '火星', 'bags': {'beibao': ['coach', 'abc'], 'qianbao': ['ysl']}, 'age': 18, 'id': 3, 'shengao': '185'}

 

 

内置函数

 

 1 dic1 = {'name': 'titan', 'age':20}
 2 # 计算字典元素个数，即键的总数
 3 print(len(dic1))
 4 # 字典(Dictionary) str() 函数将值转化为适于人阅读的形式，以可打印的字符串表示
 5 print(str(dic1))
 6 # 返回输入的变量类型，如果变量是字典就返回字典类型
 7 print(type(dic1))
 8 
 9 //输出:
10 2
11 {'name': 'titan', 'age': 20}
12 <class 'dict'>

 

内置方法   

 copy（）、fromkeys()方法、get() 和 setdefault()方法、update()方法、pop() 和 popitem() 方法、其他方法

 

copy()方法

• copy()函数返回一个字典的浅复制
• 直接赋值和 copy 的区别

•  1 dict1 =  {'user':'runoob','num':[1,2,3]}
   2  
   3 dict2 = dict1          # 浅拷贝: 引用对象
   4 dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
   5  
   6 # 修改 data 数据
   7 dict1['user']='root'
   8 dict1['num'].remove(1)
   9  
  10 # 输出
  11 print(dict1)
  12 print(dict2)
  13 print(dict3)
  14 
  15 
  16 # 输出结果
  17 {'num': [2, 3], 'user': 'root'}
  18 {'num': [2, 3], 'user': 'root'}
  19 {'num': [2, 3], 'user': 'runoob'}
  20 
  21 实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，   dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改

  fromkeys()方法

  • fromkeys() 函数用于创建一个新字典，
  • 参数一: 以序列seq中元素做字典的键
  • 参数二: value为字典所有键对应的初始值(可选参数) 

  •  1 dict.fromkeys(seq[, value])
     2 
     3 # 使用
     4 dic2 = dict.fromkeys(['name', 'titan'])
     5 print(dic2)
     6 dic3 = dict.fromkeys(['name', 'titan'], 20)
     7 print(dic3)
     8 
     9 # 输出:
    10 {'name': None, 'titan': None}
    11 {'name': 20, 'titan': 20}

    get() 和 setdefault()方法

    • get() 函数返回指定键的值，如果值不在字典中返回默认值
    • setdefault()和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值(同事也会把键值对添加到字典中)
    • 参数一: 字典中要查找的键。
    • 参数二: 如果指定键的值不存在时，返回该默认值值(可选参数)   ,即找不到键的值也不会报错 

    
    

     1 dict.get(key, default=None)
     2 
     3 # 使用
     4 dic5 = {'name': 'titan', 'age':20}
     5 print(dic5.get('name'))
     6 print(dic5.get('Sex', 'man'))
     7 print(dic5.setdefault('name'))
     8 print(dic5.setdefault('Sex', 'man'))
     9 print(dic5)   print(dics2.setdefault('name','Tan')) #如果这个key已经存在，那么就不修改它的值了
    10 
    11 # 输出结果:
    12 titan
    13 man
    14 titan
    15 man
    16 {'name': 'titan', 'age': 20, 'Sex': 'man'}

     

    其他方法

     1 dic2 = {'name': 'titan', 'age':20}
     2 # 判断键是否存在于字典中, 在True, 不在False
     3 print(dic2.__contains__('name'))
     4 
     5 # 以列表返回可遍历的(键, 值) 
     6 print(dic2.items())
     7 
     8 # 删除字典内所有元素
     9 dic2.clear()
    10 print(dic2)
    11 
    12 
    13 # 输出结果:
    14 True
    15 dict_items([('name', 'titan'), ('age', 20)])
    16 {}

     

切片：就是list取值的一种方式 

 1 # 切片 ： 就是list取值的一种方式
 2  3 l = ['a','b','c','d','e','j','k','l','m','n','o']
 4     # 0    1  2   3   4   5   6    7   8   9   10
 5 print(l[2:8])  # 顾头不顾尾
 6 print(l[:5])  # 如果最前面没写的话，代表从0开始取的
 7 print(l[4:])  # 如果冒号后面的没写的话，代表去到最后
 8 print(l[:])  # 如果冒号后面的没写的话，代表去到最后
 9 print(l[::3])  # 步长，也就是代表隔几个取一次，
10 nums = list(range(1,11))

 # 1 2 3 4 5 6 7 8 9 10

11 print(nums[1::2]) # 取偶数， 12 print(nums[::2]) # 取奇数 13 14 print(nums) 15 print(nums[::-1]) # 取奇数 16 # 如果最后面的步长是正数的话， 那就从左到右开始取值 17 # 如果后面的步长是负数的话，那么就从右往左开始取值 18 19 #输出结果 ： 20 ['c', 'd', 'e', 'j', 'k', 'l'] 21 ['a', 'b', 'c', 'd', 'e'] 22 ['e', 'j', 'k', 'l', 'm', 'n', 'o'] 23 ['a', 'b', 'c', 'd', 'e', 'j', 'k', 'l', 'm', 'n', 'o'] 24 ['a', 'd', 'k', 'n'] 25 [2, 4, 6, 8, 10] 26 [1, 3, 5, 7, 9] 27 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 28 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

 

切片 ，同样也使用于字符串

 1 # 切片 同样适用于字符串。
 2 words='中秋节要放假'
 3 print(words[::-1])
 4 for index,w in enumerate(words):
 5     print('每次打印的',index,w)
 6 
 7 
 8 # 输出结果 ：
 9 假放要节秋中
10 每次打印的 0 中
11 每次打印的 1 秋
12 每次打印的 2 节
13 每次打印的 3 要
14 每次打印的 4 放
15 每次打印的 5 假

 

回文算法 ： 反过来 倒过去都一样 

 1 # 回文算法，反过来倒去过都一样
 2 # 如：
 3 #s ='上海自来水来自海上'
 4 # 1232321
 5 # 1111
 6 # 5678 8765 
 7 #
 8 for i in range(10):
 9     s = input('请输入一个字符串：')
10     if len(s)<2:
11         print('字符串长度必须大于1')    
12     elif s==s[::-1]:
13         print('是回文')
14     else:
15         print('不是回文')
16 
17 
18 #  输出结果 ：
19 请输入一个字符串：1232321
20 是回文
21 请输入一个字符串：56788765
22 是回文
23 请输入一个字符串：56788765
24 是回文
25 请输入一个字符串：1
26 字符串长度必须大于1
27 请输入一个字符串：11
28 是回文
29 请输入一个字符串：

 

字符串的常用方法    s='anc'    s.upper()    s.lower()    s.capitalize()    s.split(',')    s.strip('abc')    s.lstrip()    s.rstrip()    s.replace('old','new')    s.endswith('xxx.mp3')    s.startswith('186')    ','.join('sdfsdfds')    s.isdigits()    s.isalnum()    s.zfill(5)

来源：https://www.cnblogs.com/tanzitanzi/p/9553731.html