1、字符串格式化：

有4中方式可以格式化字符串

  1. import datetime
  3. uname = input('请输入你的用户名：')
  4. # today = str(datetime.datetime.today())
  5. #
  6. # msg = '欢迎' + uname + '登录' + ',今天的日期是：' + today  # 使用+号，必须是字符串类型
  8. today = datetime.datetime.today()
  9. msg1 = '欢迎%s登录，今天的日期是%s' % (uname, today)
  10. print(msg1)
  11. msg2 = f'欢迎{uname}登录，今天的日期是{today}'  # 只能在python3.6版本以上使用
  12. print(msg2)
  13. msg3 = '欢迎{name}登录，今天的日期是{dtime}'.format(name=uname,dtime=today)
  14. print(msg3)

2、列表

a)list操作

1)一维数组的操作
2)二维数组的操作
3)三维数组的操作

  1. l = ['sara', 'sara', 'john', 'mickey']
  3. print(l[0])  # 获取第一个元素
  4. print(l[-1])  # 获取最后一个元素
  5. # 新增
  6. l.append('alex')  # 从list末尾添加
  7. l.insert(1, 'jack')  # 从指定位置添加
  8. # 修改
  9. # l[0] = 'sara.Li'
  10. # 删除
  11. # l.pop()  # 默认删除最后一个元素
  12. # l.pop(10) # 传入一个下标，就删除指定位置的元素,如果传入的值不存在，提示index out of range
  13. # l.remove('sara')  # 删除指定元素名字，如果传入的值不存在，提示元素不在列表中；如果列表中存在多个相同的值，只删除第一个
  14. # del[-1] # 指定下标删除
  16. # 其它的方法：
  17. # l.clear()  # 清空list
  18. # print(l.count('sara'))  # 返回元素的个数,不存在返回0
  19. # print(l.index('sara1'))  # 找指定元素的下标 ,输入不存在的元素，提示元素不再列表中；一般先用count元素是否存在
  20. # l.sort(reverse=True) # 默认是升序，加reverse=True，按降序
  21. # l.reverse()
  22. # print(l)
  24. l2 = [[1,2],[3,4]] # 二维数组
  25. l3 = [[1,2,3,[4,5,6]]] # 三维数组
  27. print(l2[1][1])
  28. print(l3[0][3][2])

b)列表的练习

一般来说，嵌套的越少越好

  1. usernames = ["admin", "test", "xiaohei"]
  2. passwords = [123456, 456789, "abc123"]
  4. # for i in range(3):
  5. #     uname = input('请输入用户名；').strip()
  6. #     uPwd = input('请输入密码：').strip()
  7. #
  8. #     if uname == '' or uPwd == '':
  9. #         print('用户名/密码不能为空')
  10. #     elif uname.count(uname) == 0:
  11. #         print('用户名不存在')
  12. #     else:
  13. #         index = usernames.index(uname)
  14. #         password = str(passwords[index])
  15. #         if uPwd == password:
  16. #             print('登录成功')
  17. #             break
  18. #         else:
  19. #             print('密码错误')
  20. # else:
  21. #     print('登录错误次数过多')
  22. for i in range(3):
  23.     uname = input('请输入用户名；').strip()
  24.     uPwd = input('请输入密码：').strip()
  26.     if uname == '' or uPwd == '':
  27.         print('用户名/密码不能为空')
  28.         continue
  29.     elif uname.count(uname) == 0:
  30.         print('用户名不存在')
  31.         continue
  32.     index = usernames.index(uname)
  33.     password = str(passwords[index])
  34.     if uPwd == password:
  35.         print('登录成功')
  36.         break
  37.     else:
  38.         print('密码错误')
  39. else:
  40.     print('登录错误次数过多')

c)列表的循环

  1. users = [
  2.     ["admin", 123456],
  3.     ["test", 456789],
  4.     ["xiaohei", "abc123"],
  5. ]
  6. # 判断元素是否在list中
  8. # usename = input('请输入用户名：')
  9. # if usename in usernames:
  10. #     print('用户名存在')
  11. # else:
  12. #     print('用户名不存在')
  14. # for username in usernames:
  15. #     print(username)
  16. for i in range(3):
  17.     uname = input('请输入用户名；').strip()
  18.     uPwd = input('请输入密码：').strip()
  20.     if uname == '' or uPwd == '':
  21.         print('用户名/密码不能为空')
  22.         continue
  23.     elif uname.count(uname) == 0:
  24.         print('用户名不存在')
  25.         continue
  26.     for user in users:
  27.         password = str(user[1])
  28.         if uPwd == password:
  29.             print('登录成功')
  30.             quit()
  31.         else:
  32.             print('密码错误')
  33. else:
  34.     print('登录错误次数过多')

3、布尔类型

True，False

  1. usernames = ["admin", "test", "xiaohei"]
  2. print('admin' in usernames)
  3. #if 表达式后面要么是True或者False

4、字典

a)字典的基本操作

  1. import pprint
  3. # 字典是无序的
  5. stus = {
  6.     'name': 'sara',
  7.     'id': 1,
  8.     'age': 18,
  9.     'addr': '北京',
  10.     'height': 188,
  11. }
  12. # 获取元素
  13. # print(stus.get('name1')) # 输入一个不存在的key值，返回None
  14. # print(stus.get('sex','女')) # 获取不到对应的key值，把女当做sex 对应的value值
  15. # print(stus['name1']) # 输入一个不存在的key值，报错提示KeyError
  17. # 修改
  18. stus['age'] = 36
  19. # 新增
  20. stus['phone'] = 110
  21. stus.setdefault('email', 'abc@qq.com')
  22. # 新增存在的key,setdefault不会修改原始的值，但是dict['name']会
  23. stus['phone'] = 119
  24. stus.setdefault('email', '123@qq.com')
  25. # 删除
  26. # stus.pop('age')  # 删除指定的key值
  27. # del stus['age']
  28. # stus.popitem()  # 随机删除一个元素
  29. # pprint.pprint(stus, indent=4)
  30. # 其它方法
  31. # stus.clear() # 清空字典
  32. print(stus.values())  # 字典里面所有的value
  33. print(stus.keys())  # 字典里面所有的key
  34. print(stus.items())  # 把字典转成二维数组，二维数组里面的每个元素就是字典的key，value
  35. stu2 = {'money': 1000}
  36. stus.update(stu2)  # 把一个字典里面的值，放到另外一个字典里面去；字典的合并
  37. pprint.pprint(stus, indent=4)

b)字典的嵌套

  1. import pprint
  3. info = {
  4.     'sara': {
  5.         'age': 18,
  6.         'addr': 'beijing',
  7.         'cars': ['bmw', 'ben-z', 'audi']
  8.     },
  9.     'lily': {
  10.         'house': {
  11.             'bj': ['海淀区', '昌平区', '朝阳区', '西城区'],
  12.             'sh': ['静安区', '闸北区']
  13.         },
  14.         'money': 5000
  15.     }
  16. }
  17. # cars =info.get('sara').get('cars')
  18. # cars.append('tesla')
  19. info['lily']['house']['bj'].remove('昌平区')
  20. info['lily']['money'] +=5000000
  21. pprint.pprint(info)

c)字典的练习

  1. import datetime
  2. users = {
  3.     "admin":123456,
  4.     "test":456789,
  5.     "dev":"acb12234"
  6. }
  8. import datetime
  9. today = datetime.datetime.today()
  10. for i in range(3):
  11.     uname = input("username:").strip()
  12.     pwd = input("password:").strip()  #
  13.     if uname == "" or pwd == "":
  14.         print("账号/密码不能为空！")
  15.     elif uname not in users.keys():
  16.         print("账号不存在！")
  17.     else:
  18.         password = str(users[uname])
  19.         if password == pwd:
  20.             print("欢迎%s登录，今天的日期是%s" % (uname,today))
  21.             break
  22.         else:
  23.             print("密码错误！")
  24. else:
  25.     print("输入错误次数已经达到3次！")

d)字典的循环

  1. d = {'admin': 123456, 'test': 56789}
  2. # 字典的循环
  3. # 第一种方式效率比较高，直接拿着key找value
  4. for k in d:
  5.     print(k)  # 取的是字典的key admin test
  6.     print(k, d.get(k))
  7. # dict_items([('admin', 123456), ('test', 56789)])，先把字典转换成二维数组
  8. for k, v in d.items():
  9.     print(d.items())
  10.     print(k, v)

e) 判断一个key值是否存在字典里

  1. d = {'admin': 123456, 'test': 56789}
  2. u = 'admin'
  3. print(u not in d) # 用这种方式更方便
  4. print(u not in d.keys())

f)给字典设置默认值

  1. from collections import defaultdict
  2. # info = defaultdict(list)
  3. info = {}
  4. info['abc'] = ['123']
  5. info['abc'].append('456')
  6. print(info)  # {'abc': ['123', '456']}
  8. info1 = defaultdict(list)
  9. info1.setdefault('123',[])
  10. info1['123'].append('456')
  11. print(info1) # defaultdict(<class 'list'>, {'123': ['456']})
  13. test_list = ['1','2']
  14. info2 = {}.fromkeys(test_list,'') # {'1': '', '2': ''}

g)字典排序

  1. stu_score = {
  2.     "a": 100,
  3.     "b": 99,
  4.     "c": 77,
  5.     "d": 23523,
  6.     "e": 232,
  7.     "f": 2323
  8. }
  9. print(stu_score.items()) # dict_items([('a', 100), ('b', 99), ('c', 77), ('d', 23523), ('e', 232), ('f', 2323)])
  11. def func(l):
  12.     return l[-1]
  13. print(dict(sorted(stu_score.items(),key=func)))
  14. print(dict(sorted(stu_score.items(),key=lambda l:l[-1])))

我们可以用sorted高阶函数或者用列表的.sort()方法。

sorted高阶函数

  1. d={'a':1,'c':3,'b':2}    # 首先建一个字典d
  3. #d.items()返回的是： dict_items([('a', 1), ('c', 3), ('b', 2)])
  5. d_order=sorted(d.items(),key=lambda x:x[1],reverse=False)  # 按字典集合中，每一个元组的第二个元素排列。
  6.                                                            # x相当于字典集合中遍历出来的一个元组。
  7. print(d_order)     # 得到:  [('a', 1), ('b', 2), ('c', 3)]

下面是sorted排序方法的详细解释：

  1. sorted高阶函数语法格式： sorted(可迭代对象,key=函数名,reverse=False/True)

    作用：从可迭代对象中，依次取出一个元素，该元素再按照key规定的排列依据排序。

    可迭代对象：即可依次取值的对象，例如：集合，序列（列表，字符串，元组），字典等。

    key : 是列表排列的依据，一般可以自定义一个函数返回排序的依据，再把函数名绑定给key。

    reverse : 译为反转，reverse默认等于False，从小到大排序。等于True时，从大到小排序。

  2. 匿名函数lambda的格式： 函数名 = lambda [形参1,形参2,…] : ，返回操作语句块产生的结果并绑定给函数名。

例如： key=lambda x : x[1] 

  1.         x：相当于字典集合中的一个**元组**， 例：dict_items([('a', 1), ('c', 3), ('b', 2)])中的**('a', 1)或('c', 3)或('b', 2)**
  3.        ** x[1]**: 返回x中的第二个元素，即键值对元组中的值。dict_items([('a', 1), ('c', 3), ('b', 2)])中的1或2或3

注意：

（1） sorted函数中的可迭代对象不要用字典d，那样只能迭代出的字典d的键。要用d.items()才可迭代出字典的键值对。

  1. 例：不能用 d_order=sorted(d,key=lambda x:x[1],reverse=False)
  3.         要用 d_order=sorted(d.items(),key=lambda x:x[1],reverse=False)

（2） sorted函数排好序后，要绑定一个对象(赋值)，例：d_order=sorted(d.items(),key=lambda x:x[1],reverse=False).

  1.  因为字典是无序类型，用sorted函数排好序后不绑定d_order，字典会自动打乱顺序。

原文链接：https://blog.csdn.net/cxcxrs/article/details/82459800

h)两个字典合并成一个

1.使用update 方法

  1. >>> u1 = {"name": "xiaoming", "age": 27}
  2. >>> u1_info = {"gender": "male"}
  3. >>>
  4. >>> u1.update(u1_info)
  5. >>> print(u1)
  6. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}

如果想使用 update 这种最简单、最地道原生的方法，但又不想更新到自己身上，而是生成一个新的对象，那请使用深拷贝。

  1. >>>u1 = {"name": "xiaoming", "age": 27}
  2. >>> u1_info = {"gender": "male"}
  3. >>>
  4. >>> from copy import deepcopy
  5. >>>
  6. >>> full_u1 = deepcopy(u1)
  7. >>> full_u1.update(u1_info)
  8. >>>
  9. >>> print(full_u1)
  10. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}
  11. >>> print(u1)
  12. {"name": "xiaoming", "age": 27}

2. 先解包再合并字典

使用 ** 可以解包字典，解包完后再使用 dict 或者 {} 就可以合并。

  1. >>> u1 = {"name": "xiaoming", "age": 27}
  2. >>> u1_info = {"gender": "male"}
  3. >>>
  4. >>> full_u01 = {**u1, **u1_info}
  5. >>> print(full_u01)
  6. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}
  7. >>>
  8. >>> full_u02 = dict(**u1, **u1_info)
  9. >>> print(full_u02)
  10. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}

3. 借助 itertools

在 Python 里有一个非常强大的内置模块，它专门用于操作可迭代对象。
正好我们字典也是可迭代对象，自然就可以想到，可以使用 itertools.chain() 函数先将多个字典（可迭代对象）串联起来，组成一个更大的可迭代对象，然后再使用 dict 转成字典。

  1. >>> import itertools
  2. >>>
  3. >>> profile = {"name": "xiaoming", "age": 27}
  4. >>> ext_info = {"gender": "male"}
  5. >>>
  6. >>>
  7. >>> dict(itertools.chain(profile.items(), ext_info.items()))
  8. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}

4. 借助 ChainMap

如果可以引入一个辅助包，那我就再提一个， ChainMap 也可以达到和 itertools 同样的效果。

  1. >>> from collections import ChainMap
  2. >>>
  3. >>> profile = {"name": "xiaoming", "age": 27}
  4. >>> ext_info = {"gender": "male"}
  5. >>>
  6. >>> dict(ChainMap(profile, ext_info))
  7. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}

使用 ChainMap 有一点需要注意，当字典间有重复的键时，只会取第一个值，排在后面的键值并不会更新掉前面的（使用 itertools 就不会有这个问题）。

  1. >>> from collections import ChainMap
  2. >>>
  3. >>> profile = {"name": "xiaoming", "age": 27}
  4. >>> ext_info={"age": 30}
  5. >>> dict(ChainMap(profile, ext_info))
  6. {'name': 'xiaoming', 'age': 27}

5. 使用dict.items() 合并

在 Python 3.9 之前，其实就已经有 | 操作符了，只不过它通常用于对集合（set）取并集。
利用这一点，也可以将它用于字典的合并，只不过得绕个弯子，有点不好理解。
你得先利用 items 方法将 dict 转成 dict_items，再对这两个 dict_items 取并集，最后利用 dict 函数，转成字典。

  1. >>> profile = {"name": "xiaoming", "age": 27}
  2. >>> ext_info = {"gender": "male"}
  3. >>>
  4. >>> full_profile = dict(profile.items() | ext_info.items())
  5. >>> full_profile
  6. {'gender': 'male', 'age': 27, 'name': 'xiaoming'}

当然了，你如果嫌这样太麻烦，也可以简单点，直接使用 list 函数再合并（示例为 Python 3.x ）

  1. >>> profile = {"name": "xiaoming", "age": 27}
  2. >>> ext_info = {"gender": "male"}
  3. >>>
  4. >>> dict(list(profile.items()) + list(ext_info.items()))
  5. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}

若你在 Python 2.x 下，可以直接省去 list 函数。

  1. >>> profile = {"name": "xiaoming", "age": 27}
  2. >>> ext_info = {"gender": "male"}
  3. >>>
  4. >>> dict(profile.items() + ext_info.items())
  5. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}

6. 最酷炫的字典解析式#

Python 里对于生成列表、集合、字典，有一套非常 Pythonnic 的写法。
那就是列表解析式，集合解析式和字典解析式，通常是 Python 发烧友的最爱，那么今天的主题：字典合并，字典解析式还能否胜任呢？
当然可以，具体示例代码如下：

  1. >>> profile = {"name": "xiaoming", "age": 27}
  2. >>> ext_info = {"gender": "male"}
  3. >>>
  4. >>> {k:v for d in [profile, ext_info] for k,v in d.items()}
  5. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}

7. Python 3.9 新特性

在 2 月份发布的 Python 3.9.04a 版本中，新增了一个抓眼球的新操作符操作符： |， PEP584 将它称之为合并操作符（Union Operator），用它可以很直观地合并多个字典。

  1. >>> profile = {"name": "xiaoming", "age": 27}
  2. >>> ext_info = {"gender": "male"}
  3. >>>
  4. >>> profile | ext_info
  5. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}
  6. >>>
  7. >>> ext_info | profile
  8. {'gender': 'male', 'name': 'xiaoming', 'age': 27}

除了 | 操作符之外，还有另外一个操作符 |=，类似于原地更新。

  1. >>> ext_info |= profile
  2. >>> ext_info
  3. {'gender': 'male', 'name': 'xiaoming', 'age': 27}
  4. >>>
  5. >>>
  6. >>> profile |= ext_info
  7. >>> profile
  8. {'name': 'xiaoming', 'age': 27, 'gender': 'male'}

文章来自于：https://www.cnblogs.com/wongbingming/p/12669854.html

4、元祖

  1. # 元祖是不能修改
  2. # 只有两个方法，count和index
  3. # 元祖里面只有一个值时，需要在值后面加逗号，否则类型是str
  4. names = ('sara', 'john')
  5. print(names[0])
  6. for name in names:
  7.     print(name)
  8. print(names.count('sara'))
  9. print(names.index('john'))
  11. names = ('sara',)
  12. print(type(names)) # <class 'tuple'>

5、字符串的操作

  1. # 字符不能修改
  2. msg = '   abc'
  3. msg2 = 'abc\n'
  4. msg3 = ' dfdfd   dfdfd  '
  5. msg4 = 'abc.jpg'
  6. new_msg = msg.strip()  # 默认去掉字符串两边的空格和换行符
  7. # print(msg)  #    abc
  8. # print(new_msg) # abc
  9. # print('abc\n'.strip())
  10. # print(msg3.rstrip()) # 只去除右边的空格和换行符
  11. # print('abc.jpg'.strip('.jpg')) # 如果指定了一个字符串，就去掉指定的字符串
  12. words = 'sdffgdsdfdfdfsd'
  13. # print(words.count('s')) # 字符串出现的次数
  14. # print(words.index('a')) # 如果查询不到，就报错substring not found；查找到的话，返回下标
  15. # print(words.find('s')) # 如果查询不到字符串，返回-1；默认不写，从开头开始查找；查找到的话，返回下标
  16. # print(words.find('s',5)) # 如果查询不到字符串，返回-1;可以指定从下标为5的地方开始查询s
  18. # print(words.replace('sd','SD')) # 替换字符串,默认把所有符合条件的字符串的都替换 SDffgdSDfdfdfSD
  19. # print(words.replace('sd','SD',1)) # 替换字符串,默认把所有符合条件的字符串的都替换 SDffgdsdfdfdfsd
  20. # print('abc  dfgfd'.replace(' ','')) # 替换字符串,默认把所有符合条件的字符串的都替换 SDffgdsdfdfdfsd
  21. # print(words.upper())  # SDFFGDSDFDFDFSD
  22. # print(words.lower()) # sdffgdsdfdfdfsd
  23. # print(words.isdigit()) # 判断字符串里面是否都是整数x# msg.isupper()
  24. # print(words.islower()) # 判断字符串里面是否都是小写字母
  25. # print(words.isupper()) # 判断字符串里面是否都是大写字母
  26. # print('123.jpg'.startswith('123')) # 判断字符串是否以123开头 返回True ，False
  27. # print('123.jpg'.endswith('.jpg')) # 判断字符串是否以.jpg结尾 返回True ，False
  28. # print(' '.isspace()) # 判断字符串是否是空格
  29. # print('Abc'.istitle())  # 字符串首字母是否是大写开头
  30. # print('登录结束'.center(30,'*'))
  31. # print('！123'.isalnum())  # 字符串如果是字母、数字、中文就返回True，也就是不包含特殊符号
  32. # print('67'.isalpha())  # 字符串如果是字母、中文就返回True
  33. num = input('请输入数字：')
  34. print(num.zfill(3))  # 给一个指定的长度，如果长度不够，自动在前面补零

a)split和join

  1. # msg = 'sara,jack,mile'
  2. # res = msg.split(',') # 以逗号方式来分割字符串
  3. # print(res) # ['sara', 'jack', 'mile']
  4. stu = ['sara', 'jack', 'mile']
  6. # 如果使用join，前提是list里面的元素必须是字符串；把列表转换成字符串,
  7. # print(''.join(stu)) # sarajackmile
  8. # print(' '.join(stu)) # sara jack mile
  9. # print(','.join(stu)) # sara,jack,mile
  10. ret = '='.join(stu) # sara,jack,mile
  11. print(ret) # sara=jack=mile

b）字符串练习

  1. s = '''
  2. username=a;pwd=123        15934567678
  3. username=b;pwd=123        15934567678
  4. username=c;pwd=123        15934567678
  5. username=d;pwd=123        15934567678
  6. username=e;pwd=123        15934567678
  7. '''
  8. students = {}
  9. for line in  s.split('\n'):
  10.     if line.strip():
  11.     # if line.strip() != '':
  12.         user_info, phone = line.split()
  13.         uname, upwd = user_info.split(';')
  14.         uname_filed, user = uname.split('=')
  15.         upwd_filed, pwd = upwd.split('=')
  16.         students['user'] = user
  17.         students['password'] = pwd
  18.         students['phone'] = phone
  19.         print(students)