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

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

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

 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里面的每一个元素

 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 # 增加列表元素
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, ‘小月‘]

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

# 删
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, ‘强‘]

 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]         对原列表进行排序, 如果指定参数，则使用比较函数指定的比较函数

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

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 二

 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‘]

 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‘)   #从元组中找出某个值第一个匹配项的索引位置

 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():
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‘])
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‘>

 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 请输入一个字符串：