2022年 11月 9日

python基础（小甲鱼python入门笔记）

序章：

PyPi:拥有许多第三方模块

功能：数学运算，人工智能，神经网络框架，自动化部署

课程内容：语法知识，案例开发

环境搭建和课程介绍：

  • 在https://www.python.org/downloads/官网下载python最新版（挂梯子），安装时点击自动配置环境文件，然后傻瓜式安装
  • 鱼c论坛配套资源
  • 在交互式界面输入import this （一个官方彩蛋）

用python设计第一个游戏

  • 编辑模式切换：在idle点击file然后new file 新建文件（此处我使用pycharm）
  1. temp = input("不妨猜一下小甲鱼心里想的是哪个数字？")
  2. guess = int(temp)
  3.  
  4. if guess==8:
  5.     print("猜对，蛔虫")
  6.     print("猜对无奖励")
  7. else:
  8.     print("猜错")
  9. print("游戏结束")
  • 几点问题：
  1. 符号是否为英文（为了更方便的分辨出中英文符号可以修改字体为consolas）
  2. 请检查缩进是否正确（非常关键，python代码规范为pep8指导手册）
  3. 函数拼写问题
  • 内置函数：input ，print（”输出内容“）（输入dir(builtins)可以看到所有内置函数）

变量和字符串

  • 变量（variable）
  1. x = 3#变量赋值
  2. print(x)#输出变量
  1. 变量名的起名规则：
  1. 1）命名的规范性
  2.  
  3. 变量名可以包括字母、数字、下划线，但是数字不能做为开头。例如：name1是合法变量名，而1name就不可以。
  4. 系统关键字不能做变量名使用
  5. 除了下划线之个，其它符号不能做为变量名使用
  6. Python的变量名是除分大小写的
  7. 2）驼峰命名法
  8.  
  9. 大驼峰:每一个单词的首字母都大写       FirstName LastName
  10. 小驼峰:第一个单词以小写字母开始，后续单词的首字母大写     firstName lastName
  1. 不同变量的值可以传递
  • 字符串（string）
  1. Single quotes:使用单引号将文本包含
print('i love china')
  1. Double quotes:使用一对双引号将文本包含
print("i love china")
  1. Triple quotes:用来解释class，function，modules的定义（Triple quotes里的语句会执行。#是注释不会执行#后面的语句）。三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。三个连续的单引号或者双引号
  1. #123
  2. '''123'''
  1. 三种引号作用：为了避免文本里面的不可避免的单引号以及双引号
  2. 也可以在引号前加转义字符”\“：\n(换行)，”\“也可加在代码末尾表示代码未结束。
  3. 字符串相加会拼接
  1. "520"+"1314"
  2. 5201314
  3. print("我每天爱你3000遍!\\n"*3000)

讲解代码

  1. temp = input("你是谁？")
  2. 你是谁？煎饼狗子
  3. > print(temp)
  4. 煎饼狗子
  5. >

  • if else 语句中的比较运算符

    无标题

改进小游戏

  1. temp = input("不妨猜一下小甲鱼心里想的是哪个数字？")
  2. guess = int(temp)
  3.  
  4. if guess==8:
  5.     print("猜对，蛔虫")
  6.     print("猜对无奖励")
  7. else:
  8.     if guess < 8:
  9.         print("小啦")
  10.     else:
  11.         print("大啦")
  12.  
  13. print("游戏结束")
  14. #python通过缩进将不同层级的语句进行划分
  15. #else里面进行了嵌套

  • while条件：

    如果条件为真执行while里的语句

    1. count = 3
    2. while count > 0:
    3.  temp = input("不妨猜一下小甲鱼心里想的是哪个数字？")
    4.  guess = int(temp)
    5.  
    6.  if guess==8:
    7.     print("猜对，蛔虫")
    8.     print("猜对无奖励")
    9.  else:
    10.     if guess < 8:
    11.         print("小啦")
    12.     else:
    13.         print("大啦")
    14.   count = count - 1
    15.  
    16. print("游戏结束")

  • break语句：

    执行到break语句会直接跳出循环

  • import+模块名导入

  1. import random
  2. random.randint(1,10)#1-10取随机数
  1. import random
  2. answer = random.randrange(1,10)
  3. count = 3
  4. while count > 0:
  5.  temp = input("不妨猜一下小甲鱼心里想的是哪个数字？")
  6.  guess = int(temp)
  7.  
  8.  if guess==answer:
  9.     print("猜对，蛔虫")
  10.     print("猜对无奖励")
  11.  else:
  12.     if guess < answer:
  13.         print("小啦")
  14.     else:
  15.         print("大啦")
  16.         count = count - 1
  17.  
  18. print("游戏结束")

random.getstate()#获取随机数种子加工后的随机数生成器的内部状态

random.setstate()#可以将上一步保存的随机数状态重现，导致随机数和上次一样

数字类型

  • 整数（integer）：python的整数长度是不受限制 的
  1. 6/2
  2. 3.0
  • 浮点数（float）：不是百分之百精确
  1. 0.1+0.2
  2. 0.30000000004
  3.

通过decimal模块使浮点数精确

  1. import decimal
  2. a = decimal.Decimal('0.1')
  3. b = decimal.Decimal('0.2')
  4. print(a+b)
  5. 0.3
  • 复数（complex）：
  1. 1 + 2j
  2. (1+2j)
  3. x = 1 + 2j
  4. x.real#获取实部
  5. 1.0
  6. x.imag#获取虚部
  7. 2.0

  • //（取比目标结果小的最大整数）：3/2=1，-3/2=2

    abs(x) x的绝对值

    int(x) 将x转化成整型

    float(x) 将x转化为浮点型

    complex(re,im) 返回一个复数 re为实部，im为虚部

    c.conjugate() 返回c的共轭复数

    divmod(x,y) 返回（x//y，x%y）

    pow(x,y) 计算x的y次方

    x**y 计算x的y次方

布尔类型

  • bool()内置函数直接给出ture或者false

    bool（False）为假

    bool（’False‘）为真

  • 定义为False的对象：none，false

  • 值为0的数字类型：0，0.0，0j，Decimal（0），Fraction（0，1）

  • 空的序列和集合：‘’，（），[]，{}，set（），range（0）

  • 逻辑运算符：

    1. and:左右都为同时true，结果为true
    2. or：左右有一个为true，结果为true
    3. not：如果操作数为true结果为false

短路逻辑和运算符优先级

  • 短路逻辑：从左到右，当第一个操作数的值无法确定逻辑运算结果时，才对第二个数求值
  • 运算符优先级：

了不起的分支循环

  • 分支语句：

    1. if语句：判断一个条件，若成立就执行代码块或某条语句
    2. if else：判断一个条件，若成立就执行代码块或某条语句，若不成立就执行另一个代码块
    3. if elif….. elif……：分别判断
    4. if elif….. elif……else…..：表示上面的如果都不成立则执行else里的语句
    5. 条件成立时的语句 if 判断条件 else 条件不成立时的语句

  • 循环结构：

    1. while循环：while 条件

      1.                  语句

    2. for循环

    3. continue：只会跳出本轮循环，如条件成立还会执行下一轮循环

    4. else：当循环条件不再为真的时候，else语句才被执行。当使用break语句跳出循环，循环外的else语句不会执行

    5. 循环嵌套：break和continue只能作用于一层循环体

    6. for 变量 in 可迭代对象 ststament（s）

    1. >>> for each in "fishc":#整型不能迭代
    2. ...     print(each)
    3. ...
    4. f
    5. i
    6. s
    7. h
    8. c

    1. range（）：生成一个数字序列

      range（stop）：生成0-stop-1的整数数列

      range（start，stop）：生成start-stop-1

      range（start，stop，step）：生成start-stop-1，step为跨度

      1. >>> for n in range(2,10):
      2. ...     for x in range(2,n):
      3. ...             if n % x == 0:
      4. ...                     print(n,"=",x,'*',n//x)
      5. ...                     break
      6. ...     else:
      7. ...             print(n,"是一个素数")
      8. ...
      9. 2 是一个素数
      10. 3 是一个素数
      11. 4 = 2 * 2
      12. 5 是一个素数
      13. 6 = 2 * 3
      14. 7 是一个素数
      15. 8 = 2 * 4
      16. 9 = 3 * 3

列表：列表可变，字符串不可变

  • 创建列表：用中括号将所有元素包裹起来，不同元素用逗号分隔

    rhyme = [1,2,3,4,“上山打老虎”]

  • 列表切片：将单个索引值改成范围

    rhyme[0:3]#打印前三个元素

    rhyme[:3]#打印前三个元素

    rhyme[3:]#从下标为3的元素开始打印

    rhyme[:]#打印所有元素

    rhyme[0,6,2]#以跨度为2打印

    1. appen():在列表末尾添加
    1. >>> s = [1,2,3,4,5]
    2. >>> s[len(s):] = [6]
    3. >>> s
    4. [1, 2, 3, 4, 5, 6]
    1. extend():可添加可迭代对象heros.extend（[“钢铁侠”，”黑寡妇”，”绿巨人”]）
    2. insert（a，b）：第一个参数指定位置，第二个指定元素
    3. remove（）：删除指定元素，如果列表中存在多个匹配到的元素，只会删除第一个，如果元素不存在则报错
    4. pop（）：参数为元素下标
    5. clear（）：清空列表
    6. 直接替换元素
    1. [1, 2, 3, 4, 5, 6]
    2. >>> hero = [0,1,2,3,5,5,6]#也可使用切片批量替换
    3. >>> hero[4] = 4
    4. >>> hero
    5. [0, 1, 2, 3, 4, 5, 6]

    1. sort（）:从小到大排序（有两个参数，key表示指定的排序方式，reverse表示排数结果是否反转，sort（reverse = true））

      reverse():原地反转列表元素

    2. count（）：查找元素，例如查找列表里面有多少个3

    3. index（x , star, end）：查找元素下标

    4. copy():拷贝列表

    5. 列表的加法和乘法

    1. 加法
    2. >>> s = [1, 2, 3]
    3. >>> t = [4, 5, 6]
    4. >>> s + t
    5. [1, 2, 3, 4, 5, 6]
    6. 乘法
    7. >>> s * 3
    8. [1, 2, 3, 1, 2, 3, 1, 2, 3]嵌套列表（二维列表）：
    9.

  • 嵌套列表（二维数组）

  1. >>> matrix = [[1, 2, 3],[4, 5, 6]]
  2. >>> matrix
  3. [[1, 2, 3], [4, 5, 6]]
  1. 嵌套循环
  1. >>> for i in matrix:
  2. ...     for each in i:
  3. ...             print(each)
  4. ...
  5. 1
  6. 2
  7. 3
  8. 4
  9. 5
  10. 6
  1. 两个索引值（类似二维数组）
  1. >>> matrix[1][1]
  2. 5
  1. is判断两个变量是否指向同一个对象
  1. >>> x = "fishc"
  2. >>> y = "fishc"
  3. >>> x is y
  4. True
  5. >>> x= [1, 2, 3]
  6. >>> y = [1, 2, 3]
  7. >>> x is y
  8. False
  • 列表的拷贝
  1. 浅拷贝：通过调用copy（）方法或切片拷贝
  1. >>> x = [1,2,3]
  2. >>> y = x.copy()
  3. >>> y
  4. [1, 2, 3]
  5.  
  6. >>> x = [1,2,3,4]
  7. >>> y = x[:]
  8. >>> y
  9. [1, 2, 3, 4]

浅拷贝只拷贝外层对象，若包含嵌套对象（类似二维数组）则只拷贝其引用

  1. >>> x = [[1,2,3],[4,5,6],[7,8,9]]
  2. >>> y = x[:]
  3. >>> y
  4. [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  5. >>> x[1][1] = 9
  6. >>> x
  7. [[1, 2, 3], [4, 9, 6], [7, 8, 9]]
  8. >>> y
  9. [[1, 2, 3], [4, 9, 6], [7, 8, 9]]
  1. 深拷贝
  1. >>> import copy
  2. >>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  3. >>> y = copy.copy(x)
  4. >>> x[1][1] = 0
  5. >>> y
  6. [[1, 2, 3], [4, 0, 6], [7, 8, 9]]
  7. >>> y = copy.deepcopy(x)
  8. >>> x[1][1] = 9
  9. >>> y
  10. [[1, 2, 3], [4, 0, 6], [7, 8, 9]]
  • 列表推导式：[expression for target in iterable]
  1. >>> a = [i for i in range(10)]
  2. >>> a
  3. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  4.  
  5. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  6. >>> y = [c * 2 for c in "fishc"]
  7. >>> y
  8. ['ff', 'ii', 'ss', 'hh', 'cc']
  9. >>> code = [ord(c) for c in "fishc"]#ord()内置函数，将字符转化为编码
  10. >>> code
  11. [102, 105, 115, 104, 99]
  12.  
  13. >>> x = [[1, 2, 3], [4, 9, 6], [7, 8, 9]]
  14. >>> diag = [x[i][i] for i in range(len(x))]
  15. >>> diag
  16. [1, 9, 9]#获取对角线元素
  17.  
  18. >>> s = [[0] * 3 for i in range(3)]
  19. >>> s
  20. [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

[expression for target in iterable if condition]#先执行for语句，再执行if语句，最后执行表达式

  1. >>> even = [i for i in range(10) if i % 2 == 0]
  2. >>> even
  3. [0, 2, 4, 6, 8]

[expression for target1 in iterable1

  1.            for  target2  in  iterable2
  3.       for  target3  in  iterable3

…………………………………………………..]

  1. >>> [x + y for x in"FISHC" for y in "fishc"]
  2. ['Ff', 'Fi', 'Fs', 'Fh', 'Fc', 'If', 'Ii', 'Is', 'Ih', 'Ic', 'Sf', 'Si', 'Ss', 'Sh', 'Sc', 'Hf', 'Hi', 'Hs', 'Hh', 'Hc', 'Cf', 'Ci',
  3.  'Cs', 'Ch', 'Cc']

[expression for target1 in iterable1 if condition1

  1.            for  target2  in  iterable2 if condition2
  3.       for  target3  in  iterable3 if condition3

…………………………………………………..]

元组：不可变，支持切片操作

  1. >>> rhyme = (1,2,3,4,5,"adawd")
  2. >>> rhyme
  3. (1, 2, 3, 4, 5, 'adawd')
  • 支持count（）和index（）方法
  • 列表推导式也可以用列表推导式生成一个新的元组
  • 在不会影响理解的条件下可以省略圆括号（最好不要）
  • 生成一个元素的元组 😡 = (123, )
  • 打包：生成一个元组；解包：将元组的元素一次性赋值给其他变量
  1. >>> t = (1,2,3)
  2. >>> x,y,z = t#也可以将字符串解包
  3. >>> x
  4. 1
  5. >>> y
  6. 2
  7. >>> z
  8. 3
  • 若元组中的元素是列表，则可以改变列表的值

字符串#像元组一样不可变的序列

  • 判断是否为回文数
  1. >>> x = "12321"
  2. >>> "是回文数" if x == x[::-1] else "不是回文数"
  3. '是回文数'
  • 字符串的一些方法：#生成新的字符串

  1. capitalize():大字符串首字母大写，其他字母小写

  2. casefold（）：返回一个所有字母都是小写的字符串 #可以处理其他语言

  3. title（）：字符串中每个单词首字母变大写，其他字母为小写

  4. swapcase（）：大小写反转

  5. upper（）：所有字母变大写

  6. lower（）：所有字母小写 #只能处理英语

  7. 左中右对齐：center（width，filllchar‘’）：width指定字符串宽度，fillchar指代填充字符

    1.                    ljust（width，filllchar‘’）：左对齐
    2.  
    3.              rjust（width，filllchar‘’）：右对齐
    4.  
    5.              zfill（width）：用0填充左侧
    1. >>> x = "有内鬼，停止交易"
    2. >>> x.center(5)
    3. '有内鬼，停止交易'
    4. >>> x.center(15)
    5. '    有内鬼，停止交易   '
    6. '0000000有内鬼，停止交易'

  8. 查找：count（sub[,start[,end]]）:查找sub参数指定的子字符串在字符串中出现的次数

    1.         find（sub[,start[,end]]）:定为sub参数指定的子字符串在字符串中的下标值（从左往右）
    2.  
    3.    rfind（sub[,start[,end]]）:（从右往左）（找不到的话返回-1）

    index（sub[,start[,end]]）:找不到的话返回异常

    rindex（sub[,start[,end]]）:

    1. >>> x = "上海自来水来自海上"
    2. >>> x.count("海")
    3. 2
    4. >>> x.count("海",0,5)
    5. 1
    6. >>> x.find("海")
    7. 1
    8. >>> x.rfind("海")
    9. 7

  9. 替换：expandtabs（[tabsize=8]）:使用空格替代制表符，然后返回一个新的字符串 replace(old,new,count=-1):将old参数指定的子字符串替换为new参数指定的字符串，count指替换次数（默认为-1，全部）

    translate(table):返回table参数返回的新字符串（str.maketrans(x[,y[,z]])获取table表格）

    1. >>> code = """
    2. ...             print("i")
    3. ...       print("i")"""
    4. >>> newcode = code.expandtabs(4)
    5. >>> print(newcode)
    6.  
    7.         print("i")
    8.       print("i")
    9.  
    10. >>> table = str.maketrans("abcdefg","1234567")
    11. >>> "dsvsdvsg" .translate(table)
    12. '4svs4vs7'

    22：05

    1. 判断：startswith(prefix[,start[,end]]):判断参数指定 的子字符串是否出现在字符串的起始位置

    endswith(suffix[,start[,end]])：指定的子字符串是否出现在结束位置(支持以元组形式传入多个字符串匹配)

    istitle（）：检测单词是否都已大写开头，其余为小写

    isupper（）：是否所有字母都为大写

    islower（）：小写

    isalpha（）：是否只有字母（空格也不算字母）

    isspace（）：检测是否为空白字符串（空格，制表符，\n）

    isprintable():字符串中是否都可以打印

    isdecimal，isdigit，isnumeric（）：检测是否为数字，检测的程度不同

    isalnum（）：

    isidentifier（）：检测是否为合法标识符

    1. 截取：lstrip：左侧不要留白

    rstrip：

    stricp：两侧不留白

    removeprefix（prefix）：删除指定的前缀

    removesuffix（suffix）：删除指定的后缀

    1. 拆分和拼接：partition（sep）：将字符串以参数指定的分隔符分割，返回三元组

    rpartition（sep）：从右到左

    split（sep=none，maxsplit=-1）：第一个参数指定分隔符，第二个参数指定分割次数

    rsplit：从右到左

    splitlines：按行分割，以列表返回

    join（iterable）：字符串拼接

    1. >>> ".".join(["www","ilove","com"])
    2. 'www.ilove.com'

  10. 格式化字符串：format（）：

  1. >>> "1+2={},2的平方是{}，3的立方是{}".format(1+2,2*2,3*3*3)
  2. '1+2=3,2的平方是4，3的立方是27'

序列：列表，元组，字符串

  • 可以作用于序列的运算符：+，-，*，/
  • id：返回一个指定对象的唯一标志的整数值
  • is和is not（同一性运算符）：判断id是否相同
  • in和in not：判断某元素是否包含在里面
  • del：删除一个或多个指定对象
  • list（）：转换成列表
  • tuple（）：可迭代对象转换为元组
  • str（）：转换才字符串
  • min（）和max（x，default = ”啥都没有“）：返回最大或最小值
  • len（）和sum（）：len（）参数最大值为2*63-1
  • sorted（）和reversed（）：排序，小到大，生成一个新列表，接受任何可迭代参数
  1. >>> t = ["fishc","apple","book","banana"]
  2. >>> sorted(t,key = len)
  3. ['book', 'fishc', 'apple', 'banana']
  4.  
  5. >>> s = [1,2,5,8,0]
  6. >>> reversed(s)
  7. <list_reverseiterator object at 0x00000191207A12D0>
  8. >>> list(reversed(s))
  9. [0, 8, 5, 2, 1]
  • all（）和any（）：all判断可迭代对象中是否所有元素值为真，any为是否存在
  • enumerate（s，x）：返回元组，x表示从x开始形成二元组
  1. >>> s = ["sp","su","fall","winter"]
  2. >>> enumerate(s)
  3. <enumerate object at 0x00000191207BCD00>
  4. >>> list(enumerate(s))
  5. [(0, 'sp'), (1, 'su'), (2, 'fall'), (3, 'winter')]
  • zip（）：
  1. >>> x = [1,2,3]
  2. >>> y = [4,5,6]
  3. >>> z = zip(x,y)
  4. >>> list(z)
  5. [(1, 4), (2, 5), (3, 6)]
  6.  
  7. >>> import itertools
  8. >>> a = [2,3,5,4,8]
  9. >>> z = itertools.zip_longest(x,y,a)
  10. >>> list(z)
  11. [(1, 4, 2), (2, 5, 3), (3, 6, 5), (None, None, 4), (None, None, 8)]
  • map（ord，”“）：提供计算方法，传入第一个参数
  1. >>> mapped = map(ord,"fishc")#ord方法为求参数编码
  2. >>> list(mapped)
  3. [102, 105, 115, 104, 99]
  • filter（）：类似于map函数，返回计算结果为真的迭代器
  • 可迭代对象可以多次使用，迭代器使用一次
  • iter（）：迭代对象换为迭代器
  • next（）：逐个将迭代器中元素提取出去

字典

x = {”吕布“：”口口布“，”关羽“：”关习习“}

x[“吕布”]

‘口口布’

  • 直接使用大括号创建字典
  • 使用dict（吕布 = ”口口布“）函数
  • dict（[(,),(,),(,)]）
  • dict({“吕布”：”口口布“})
  • dict（zip（[”吕布“]，[”口口布“]））
  • 增：fromkeys（iterable，【，values】）
  1. >>> d = dict.fromkeys("fish",250)
  2. >>> d
  3. {'f': 250, 'i': 250, 's': 250, 'h': 250}
  4. >>> d.pop("f")
  5. 250
  6. >>> d
  7. {'i': 250, 's': 250, 'h': 250}
  • 删：pop（）

popitem（）：删除最后一个键值对

del d[“i”]

d.clear()

  • 改：update([other])：
  1. >>> d = dict.fromkeys("fishc")
  2. >>> d
  3. {'f': None, 'i': None, 's': None, 'h': None, 'c': None}
  4. >>> d["s"] = 115
  5. >>> d
  6. {'f': None, 'i': None, 's': 115, 'h': None, 'c': None}
  7. >>> d.update({"i":105,"h":104})
  8. >>> d
  9. {'f': None, 'i': 105, 's': 115, 'h': 104, 'c': None}
  10. >>> d.get("C","这里没有")
  11. '这里没有'
  • 查：get（key[,default]）:default指定找不到时返回的值

items（）：获取键值对（都是视图对象，可以随着字典改变而改变） keys（）：获取键 values（）：获取值

  • copy（）：浅拷贝
  • 嵌套：字典可以嵌套（嵌套字典，列表等）
  • 字典推导式：
  1. >>> d = {"f":70,"i":105,"c":115}
  2. >>> b = {v:k for k,v in d.items()}
  3. >>> b
  4. {70: 'f', 105: 'i', 115: 'c'}