一.概述
    本篇笔记为个人学习内容全记录，参考的学习文档主要包含{骆昊先生}的《python100days》
    内容若有不当还请指正
    二.变量
    变量是数据的载体，简单的说就是一块用来保存数据的内存空间，变量的值可以被读取和修改，这是所有计算和控制的基础。计算机能处理的数据有很多种类型，最常见的就是数值，除了数值之外还有文本、图形、音频、视频等各种各样的数据。虽然数据在计算机中都是以二进制形态存在的，但是我们可以用不同类型的变量来表示数据类型的差异。Python中的数据类型很多，而且也允许我们自定义新的数据类型（这一点在后面会讲到），这里我们需要先了解几种常用的数据类型。

    猜数循环

    1. import random
    3. answer = random.randint(1,100)
    4. counter = 0
    5. while True:
    6.     counter += 1
    7.     number = int(input('请输入：'))
    8.     if number < answer:
    9.         print('大于')
    10.     elif number > answer:
    11.         print('小于')
    12.     else:
    13.         print('对了')
    14.         break
    15. print(f'你猜了{counter}次')

    99乘法表

    1. for i in range(1, 10):
    2.     for j in range(1, i + 1):
    3.         print(f'{i}*{j}={i * j}', end='\t')
    4.     print()

    判断素数

    1. num = int(input('输入一个正整数： '))
    2. end = int(num ** 0.5)
    3. is_prime = True
    4. for x in range(2, end + 1):
    5.     if num % x == 0:
    6.         is_prime = False
    7.         break
    8. if is_prime and num != 1:
    9.     print(f'{num}是素数')
    10. else:
    11.     print(f'{num}不是素数')

    计算最大公约数和最小公倍数

    1. x = int(input('x = '))
    2. y = int(input('y = '))
    3. if x > y:
    4.     x, y = y, x
    5. for factor in range(x, 0, -1):
    6.     if x % factor == 0 and y % factor == 0:
    7.         print(f'{x}和{y}的最大公约数是{factor}')
    8.         print(f'{x}和{y}的最小公倍数是{x * y // factor}')
    9.         break

    计算一定范围内的水仙花数

    1. # 找水仙花数
    2. min_num = int(input('请输入正整数计算范围下限: '))
    3. max_num = int(input('请输入正整数计算范围上限: '))
    4. for num in range(min_num, max_num):
    5.     low = num % 10
    6.     mid = num // 10 % 10
    7.     high = num // 100
    8.     if num == low ** 3 + mid ** 3 + high ** 3:
    9.         print(num)

    颠倒正整数

    1. num = int(input('num = '))
    2. reversed_num = 0
    3. while num > 0:
    4.     reversed_num = reversed_num * 10 + num % 10
    5.     num //= 10
    6. print(reversed_num)

    百鸡百钱问题
    公鸡5元一只，母鸡3元一只，小鸡1元三只，用100块钱买一百只鸡，问公鸡、母鸡、小鸡各有多少只？

    1. # 假设公鸡的数量为x，x的取值范围是0到20
    2. for x in range(0, 21):
    3.     # 假设母鸡的数量为y，y的取值范围是0到33
    4.     for y in range(0, 34):
    5.         z = 100 - x - y
    6.         if 5 * x + 3 * y + z // 3 == 100 and z % 3 == 0:
    7.             print(f'公鸡: {x}只, 母鸡: {y}只, 小鸡: {z}只')

    CRAPS赌博游戏

    1. from random import randint
    3. money = int(input('输入初始金额:'))
    4. while money > 0:
    5.     print(f'你的总资产为: {money}元')
    6.     go_on = False
    7.     # 下注金额必须大于0小于等于玩家总资产
    8.     while True:
    9.         debt = int(input('请下注:'))
    10.         if 0 < debt <= money:
    11.             break
    12.     # 第一次摇色子
    13.     # 用1到6均匀分布的随机数模拟摇色子得到的点数
    14.     first = randint(1, 6) + randint(1, 6)
    15.     print(f'\n玩家摇出了{first}点')
    16.     if first == 7 or first == 11:
    17.         print('玩家胜!\n')
    18.         money += debt
    19.     elif first == 2 or first == 3 or first == 12:
    20.         print('庄家胜!\n')
    21.         money -= debt
    22.     else:
    23.         go_on = True
    24.     # 第一次摇色子没有分出胜负游戏继续
    25.     while go_on:
    26.         go_on = False
    27.         current = randint(1, 6) + randint(1, 6)
    28.         print(f'玩家摇出了{current}点')
    29.         if current == 7:
    30.             print('庄家胜!\n')
    31.             money -= debt
    32.         elif current == first:
    33.             print('玩家胜!\n')
    34.             money += debt
    35.         else:
    36.             go_on = True
    37. print('你破产了, 游戏结束!')

    按数目需输出斐波那契数列从第三位往后的数

    1. # 输出斐波那契数列从2往后按需数量
    2. a, b = 1, 1
    3. c = int(input('输入想要的后续数:'))
    4. print(a, b, end=' ')
    5. for _ in range(c):
    6.     a, b = b, a + b
    7.     print(b, end=' ')

    打印素数

    1. # 打印素数
    2. num = int(input('素数范围：'))
    3. for num in range(2, num):
    4.     # 假设num是素数
    5.     is_prime = True
    6.     for factor in range(2, num):
    7.         # 在2到num-1之间寻找num的因子
    8.         # 如果找到了num的因子，num就不是素数
    9.         if num % factor == 0:
    10.             is_prime = False
    11.             break
    12.     if is_prime:
    13.         print(f'{num}是素数')

    将重复代码收敛成函数
    image.png

    1. #计算阶乘  
    2. m = int(input('m = '))
    3. n = int(input('n = '))
    4. # 计算m的阶乘
    5. fm = 1
    6. for num in range(1, m + 1):
    7.     fm *= num
    8. # 计算n的阶乘
    9. fn = 1
    10. for num in range(1, n + 1):
    11.     fn *= num
    12. # 计算m-n的阶乘
    13. fm_n = 1
    14. for num in range(1, m - n + 1):
    15.     fm_n *= num
    16. # 计算C(M,N)的值
    17. print(fm // fn // fm_n)
    19. ↓
    21. def test(num):
    22.     answer = 1
    23.     for n in range(1, num + 1):
    24.         answer *= n
    25. # 返回num的阶乘（因变量）
    26.     return answer
    28. m = int(input('m = '))
    29. n = int(input('n = '))
    30. # 当需要计算阶乘的时候不用再写重复的代码而是直接调用函数fac
    31. # 调用函数的语法是在函数名后面跟上圆括号并传入参数
    32. print(test(m) // test(n) // test(m - n))

    可变参数函数

    2. # 用星号表达式来表示args可以接收0个或任意多个参数
    3. def add(*args):
    4.     total = 0
    5.     # 可变参数可以放在for循环中去除每个参数的值
    6.     for val in args:
    7.         total += val
    8.     return total
    10. # 在调用add函数时可以传入0个或任意多个参数
    11. print(add())
    12. print(add(1))
    13. print(add(1, 2, 3))
    14. print(add(1, 2, 3, 5, 7))

    函数调用不讲了
    无非是import module ,或者使用其中的函数from module import xxx函数 as 别名

    循环遍历字符串的两种方法

    1. s = 'abc123lht'
    2. N = len(s)
    3. # for index in range(N):
    4. #    print(s[index])
    5. for ch in s:
    6.     print(ch)

    字符串切片和索引的基本示例

    1. s = 'abc123lht'
    2. N = len(s)
    4. print(s[0], s[-N])
    5. print(s[N-1], s[-1])
    6. print(s[2], s[-7])
    8. print(s[-2:-8:-1])
    9. print(s[7::-1])
    11. print(s[:1:-1])

    字符串大小写变换方法

    1. s = 'abc123lht'
    2. N = len(s)
    3. d = 'ABDDD'
    4. print(s.capitalize())
    5. print(s.title())
    6. print(s.upper())
    7. print(d.lower())
    9. Abc123lht
    10. Abc123Lht
    11. ABC123LHT
    12. abddd

    字符串查找的两种方法

    1. s = 'hello, world!'
    3. # find方法从字符串中查找另一个字符串所在的位置
    4. # 找到了返回字符串中另一个字符串首字符的索引
    5. print(s.find('or'))        # 8
    6. # 找不到返回-1
    7. print(s.find('shit'))      # -1
    8. # index方法与find方法类似
    9. # 找到了返回字符串中另一个字符串首字符的索引
    10. print(s.index('or'))       # 8
    11. # 找不到引发异常
    12. print(s.index('shit'))     # ValueError: substring not found
    1. s = 'hello good world!'
    3. # 从前向后查找字符o出现的位置(相当于第一次出现)
    4. print(s.find('o'))       # 4
    5. # 从索引为5的位置开始查找字符o出现的位置
    6. print(s.find('o', 5))    # 7
    7. # 从后向前查找字符o出现的位置(相当于最后一次出现)
    8. print(s.rfind('o'))      # 12

    判断字符串性质

    1. s1 = 'hello, world!'
    3. # startwith方法检查字符串是否以指定的字符串开头返回布尔值
    4. print(s1.startswith('He'))    # False
    5. print(s1.startswith('hel'))   # True
    6. # endswith方法检查字符串是否以指定的字符串结尾返回布尔值
    7. print(s1.endswith('!'))       # True
    9. s2 = 'abc123456'
    11. # isdigit方法检查字符串是否由数字构成返回布尔值
    12. print(s2.isdigit())    # False
    13. # isalpha方法检查字符串是否以字母构成返回布尔值
    14. print(s2.isalpha())    # False
    15. # isalnum方法检查字符串是否以数字和字母构成返回布尔值
    16. print(s2.isalnum())    # True

    格式化字符串

    1. s = 'hello, world!'
    2. print(s.center(20, '*'))
    4. print(s.rjust(20))
    6. print(s.ljust(20, '$'))
    8. ***hello, world!****
    9.        hello, world!
    10. hello, world!$$$$$$$
    12. a = 321
    13. b = 123
    14. print('%d * %d = %d' % (a, b , a * b))
    15. print('{0} * {1} = {2}'.format(a, b, a*b))
    16. print(f'{a} * {b} = {a * b}')   #py3.6后开始支持，推荐使用这种方式格式化字符串
    18. 321 * 123 = 39483
    19. 321 * 123 = 39483
    20. 321 * 123 = 39483

    image.png
    修剪字符串两边的空格

    1. s = '   jackfrued@126.com  \t\r\n'
    2. # strip方法获得字符串修剪左右两侧空格之后的字符串
    3. print(s.strip())    # jackfrued@126.com
    4. 字符串的`strip`方法可以帮我们获得将原字符串修剪掉左右两端空格之后的字符串。这个方法非常有实用价值，通常用来将用户输入中因为不小心键入的头尾空格去掉，`strip`方法还有`lstrip`和`rstrip`两个版本，相信从名字大家已经猜出来这两个方法是做什么用的。

    创建指定长度验证码函数

    1. import random
    2. ALL_CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    3. m = int(input('请输入验证码长度：'))
    4. def generate_code(code_len=m):
    5.     code = ''
    6.     for _ in range(code_len):
    7.         index = random.randrange(0, len(ALL_CHARS))
    8.         code += ALL_CHARS[index]
    9.     return code
    10. # 随机生成10个验证码
    11. for _ in range(10):
    12.     print(generate_code())
    14. 上面的函数其实还有一种更为简单的写法，直接利用`random`模块的随机抽样函数从字符串中取出指定数量的字符，然后利用字符串的`join`方法将选中的那些字符拼接起来。此外，可以利用Python标准库中的`string` 模块来获得数字和英文字母的字面常量。
    15. import random
    16. import string
    17. ALL_CHARS = string.digits + string.ascii_letters
    18. m = int(input('请输入验证码长度：'))
    19. def generate_code(code_len=m):
    20.     return ''.join(random.choice(ALL_CHARS, k=code_len))
    21. `random`模块的`sample`和`choices`函数都可以实现随机抽样，`sample`实现无放回抽样，这意味着抽样取出的字符是不重复的；`choices`实现有放回抽样，这意味着可能会重复选中某些字符。这两个函数的第一个参数代表抽样的总体，而参数`k`代表抽样的数量

    截取文件后缀名

    1. def get_suffix(filename):
    2.     """获取文件后缀名
    3.     :param filename:文件名
    4.     :return: 文件后缀
    5.     """
    6.     pos = filename.rfind('.')
    7.     return filename[pos + 1:] if pos > 0 else ''
    9. print(get_suffix('readme.txt'))       # txt
    10. print(get_suffix('readme.txt.md'))    # md
    11. print(get_suffix('.readme'))          #
    12. print(get_suffix('readme.'))          #
    13. print(get_suffix('readme'))           #
    15. #更简单的方法是直接使用`os.path`模块的`splitext`函数，这个函数会将文件名拆分成带路径的文件名和扩展名两个部分，然后返回一个二元组（下节课会讲到元组），二元组中的第二个元素就是文件的后缀名（包含`.`），如果要去掉后缀名中的`.`，可以做一个字符串的切片操作，代码如下所示。
    16. from os.path import splitext
    17. def get_suffix2(filename):
    18.     return splitext(filename)[1][1:]
    19. print(get_suffix('readme.txt'))       # txt
    20. print(get_suffix('readme.txt.md'))    # md
    21. print(get_suffix('.readme'))          #
    22. print(get_suffix('readme.'))          #
    23. print(get_suffix('readme'))           #

    走马灯循环输出字符串

    1. import os
    2. import time
    4. content = '希 望 我 2 0 2 1 财 源 广 进     '
    5. while True:
    6.     # Windows清除屏幕上的输出
    7.     os.system('cls')  
    8.     # macOS清除屏幕上的输出
    9.     #os.system('clear')
    10.     print(content)
    11.     # 休眠
    12.     time.sleep(0.2)
    13.     content = content[1:] + content[0]