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 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':'[email protected]',
 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():
27     print(k,v)
28     
29 # 无序输出 
32 email [email protected]
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'])
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': '[email protected]',
 8         'addr': '火星',
 9         'id': 1,
10         'cars':['牧马人','911','野马','劳斯莱斯']
11 
12     },
13     'hailong':{
14         'sex': '男',
15         'shengao': '185',
16         'age': 18,
17         'email': '[email protected]',
18         'addr': '火星',
19         'id': 2
20     },
21     'yangfan':{
22         'sex': '男',
23         'shengao': '185',
24         'age': 18,
25         'email': '[email protected]',
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': '[email protected]'}

36 print(len(all_stus['xiaojun']['cars']))
# 输出 
   5

37 all_stus['yangfan']['sex'] = '女'
38  print(all_stus['yangfan'])
 # 输出 

1 {'sex': '女', 'email': '[email protected]', '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': '[email protected]', '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 请输入一个字符串：

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

作者：ShmilyCoder
链接：https://www.jianshu.com/p/301f29d0f5e5
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。