去Python官网下载安装包

在安装过程中第一步需要在安装页面选择添加环境变量add Python 3.7 to PATH

安装完成之后，需要在cmd 输入python 查看python的版本号

常用的有Pycharm 、Eclipse 、 VS code

  • 见名知意
  • 变量名是由英文字母，数字和下划线
  • 不能以数字开头
  • 举例 ：
  1. name = input ('键盘输入')
  2. print  (name)

扩展：

python为引用变量，存放的是地址，计算机会根据此地址查找对象的值

扩展：python 解释器有；CPython，Jython,IronPython,pyPy….

单行注释：# 这是一个注释

多行注释：”’ 这是多行注释 ”’

转义符是为了让计算器识别字符串，例如英文的I‘m love you 在计算器输出中时，他会判断字符串，因为出现三个单引号，他识别失败，而转义符就是解决这种问题，当在I’\m love you 在输出时，他就不会讲单引号识别成单个字符串，把这个单引号当成整体内容。

\例子和\

  1. s = "使用\"创建字符串"
  2. print(s)
  3. ---使用"创建字符串
  5. a = "亲爱的宝宝们" \
  6.     "我爱你们"
  7. print(a)
  8. --亲爱的宝宝们我爱你们
  9. # 在字符串行尾的续行符，即一行未完，转到下一行继续写，使其作为完整的一行内容来输出

\n : 表示换行 换行输出 print(‘1234\n56789’)

\t：表示制表 四个空格即两个tab print(‘1234\t56789’)

r：取消转义字符

当打印输出有多个\\\ 这种情况如目录 需要使用 r 去掉转义字符

扩展

%s : 表示字符串 print(‘我叫%s，今年%s岁’ % (name, age))

%d ; 整数 print(‘我叫%s，今年%s岁’ % (name, 20)) 当在%之后加上数字，意味着这里需要留出相对应空位

%f : 浮点数 print(‘圆周率=%.6f’ % 3.1415926)

​ 在%之后加.输入位数即精确到小数点后几位

input() : 获取用户输入即键盘输入

强制转化：将一个字符串转化成其他类型

int() 将字符串类型数组转换为整数 print(‘我叫%s，今年%d岁’ % (name, int(age)))

  1. print('我叫%s，今年%d岁' % (name, int(age)))  # int()将字符串类型数字转换位整数
  2. print('我叫%s，今年%3d岁' % (name, int(age)))  # % ---我叫lll，今年 18岁
  3. print('圆周率=%f' % 3.1415926)  # %
  4. print('圆周率=%.6f' % 3.1415926)  # %

计算机需要通电工作，电的特性是高低电平，人门从逻辑上讲二进制数对应高低电平，机器也是是识别高低电平，也就是说机器只认识数字。在日常生活中，我们都是用人类能懂得字符交流，为了让机器也识别人类的字符，也就是说，需要计算机翻译人类的字符。

总结就是，字符编码就是讲人类的字符编码成计算机能识别的数字，而这有一套固定的标准。称为字符编码。

ASCII美国人指定的，规定英文字母数字和一些特殊字符与数字对应关系。最多有8位（8位8个二进制），即2**8=256。

GBK

Unicone – 2byte 内存

utf-8 1~4byte 硬盘

举例：

  1. name = input('请输入您的姓名：')
  2. age = input('请输入年龄：')
  3. # 我叫xxx，今年xx岁
  4. print('我叫' + name + '，今年' + age + '岁')
  1. print('我叫%s，今年%s岁' % (name, age))
  1. print(f'我叫{name}，今年{age}岁')

第二和第三在python常用，使用第一种也可以，但是太过于复杂。第二种和第三种记住就可以。

image-20220331135102315

  1. a = 10
  2. c = a + 1
  3. print(c)

image-20220331135431970

python最常用的数据类型，list

  1. 列表  [元素1，元素2，元素3]
  3. 元素  列表中保存的数据称为元素
  4. 元素  元素之间用逗号隔开
  5. 列表中的元素是有序的，元素的下标-index,下标从0开始
  6. 列表中可以存整数，浮点数，字符串，布尔值

正索引：从0开始

img

values: 代表元素

indexs: 索引也称为下标

负索引/反向索引：下标从尾部开始，从-1开始

img

列表操作符：

image-20220401134221199

常用函数方法：

获取元素长度len(变量)函数：

  1. # 获取元素个数
  2. print('---获取元素个数')
  3. lenth = len(name3)
  4. print(lenth)
  5. print('-----获取元素长度')
  6. print(len(name4))
  8. # 获取最后一个元素
  9. print('---获取最后一个元素')
  10. print(name3[lenth - 1])

函数扩展：

image-20220401134644500

追加元素到列表末尾和：

  1. name3.append('新疆')  # 追加元素到列表的末尾
  2. print(name3)
  3. print(name3.append('肖黄'))
  4. print(name3)

追加元素到指定位置insert(索引，‘值’)

  1. name3.insert(0, '成都')  # 追加元素到指定位置下标
  2. print(name3)

删除元素用索引pop() 默认删除最后一个:

  1. name5 = name3.pop(5)  # 删除按下标删除，并返回指定元素
  2. print(name3)
  3. print(name5)
  4. print(name3.pop(2))
  5. print(name3)
  6. print('----------')
  7. # name.pop() 默认删除最后一个
  8. print('--默认删除最后一个元素打印输出')
  9. print(name3.pop())

清空列表clear()：

  1. print(name3.clear())

删除元素用元素remove():

  1. print('---删除指定元素')
  2. print(name3.remove('深圳'))
  3. print(name3)

修改元素 根据index修改：

  1. index = name3.index('北京')  # 使用index获取值
  2. name3[index] = '地狱'
  3. print(name3)
  4. print('---修改指定元素')
  5. name3[1] = '天堂' # 修改指定元素按照索引修改
  6. print(name3)

空列表：

空列表也是有意义的，当我们需要存放一些变量是可用列表存放

  1. a = []

二维列表和多维列表：

二维列表也就是在一维列表中添加了新的列表。多维亦是如此。

  1. b = [1,2,3,[4,5,6]]
  2. print(b[1])
  3. print(b[3])

查询二维列表的值

  1. # 取二维列表，先取二维数组的下标，然后在取二维列表中的下标
  2. print(b[3][1])

注意：当下标越界或者是索引越界就会出现异常

  1. lsit index out of range 下标越界错误

元组与列表类似，不同之处在于处在元组下的元素不能修改。

img

  1. # 元组中只有一个元素时，必须补一个逗号
  2. a = (1,)
  3. print(a)
  5. # 空元组
  6. c = ()
  7. print(c)

元组和列表一样，也是个序列，与列表不同元组是不可变的，只能查询元素，增删改元素都不允许

  1. # 元组中只有一个元素时，必须补一个逗号
  2. a = (1,)
  3. print(a)
  5. # 空元组
  6. c = ()
  7. print(c)
  1. # 列表和元组进行转换
  2. # list 元组转列表   将一个序列变成列表
  3. print('---list 将一个序列变成列表')
  4. print(list(address))
  6. # tuple 列表转换元组  讲一个序列转化成元组
  7. print('---tuple 列表转换元组')
  8. score = [90, 18, 85, 46, 89, 100]
  9. print(tuple(score))

字典能够更加精确的存储数据，以键值对的形式存储。

  • 字典中每个key对应一个值，key是不可变化的
  • 字典中的数据是无序的
  • key，是唯一的，value是可变的
  • 字典的查询特别快
  • 字典是以空间换时间，会浪费内存

与列表类似有一样的方法

  1. # 字典
  2. classmates = {'王海':90, '骆纯':80, '李宁':70, '赵艳芳':88, '任收港':98, '李颖':85, '王珍':87}
  4. print(classmates)
  5. # 添加元素
  6. classmates['张玮越'] = 83
  7. print(classmates)
  8. # 删除元素
  9. classmates.pop('李宁')
  10. print(classmates)
  11. # 修改值
  12. classmates['张玮越'] = 89
  13. print(classmates)
  14. # 查询
  15. score = classmates.get('赵艳芳')
  16. print(score)
  17. # 计算字典元素个数
  18. print(len(students))
  19. # 清除所有元素
  20. print(student.clear())
  21. # 返回字典中所有的元素的主键key
  22. print(students.keys())
  23. # 返回字典中所有的元素的值value
  24. print(students.values())
  25. # 返回以列表返回可遍历的(键, 值) 元组数组
  26. print(students.items())
  28. print('--for循环遍历字典--')
  29. # 循环遍历key
  30. for i in students:
  31.     print(i,students.get(i))
  32. # 遍历value
  33. for value in students.values():
  34.     print(value)
  35. # 遍历key,value
  36. for key , value in students.items():
  37.     print(key,value)
  • 也是一组key的集合
  • setj集合也是无序的
  • set中的元素是不可重复的
  • set集合可以用来去重和关系运算
  • 使用{}大括号/花括号，只能存储不可变类型

扩展：

查看可变数据类型和不可变数据类型

不可变数据类型更改后地址发生改变，可变数据类型更改地址不发生改变

  • 不可变数据类型： 当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型。

  • 可变数据类型 ：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，对于这种数据类型，就称可变数据类型

  • 数据类型 可变/不可变
    整型 不可变
    字符串 不可变
    元组 不可变
    列表 可变
    集合 可变
    字典 可变

  • 可以使用id()方法查看

首先讲下python的流程控制

分三种：

  • 顺序结构：从上到下执行
  • 分支结构：根据条件选择执行某段代码，实现分支只有一种if
  • 循环结构：让代码重复执行，在python中，有两种for、while两种方式

  1. if单分支结构：

    if单分支结构-满足某个条件就执行某个操作，不满足就不执行

    1. # 语法 ：
    2. # if 条件语句：
    3. #    代码块
    4. age = int(input('请输入您的你年龄:'))
    5. if age <= 18:
    6.     # 缩进-indent
    7.     print('未成年')

    条件语句可以是任何有结果的表达式，比如：独立的数据、运算表达式(不能是赋值运算)、函数调用表达式

    ：固定写法

    代码块和if 保持一个缩进的一条或者多条语句；满足条件才会执行的语句

    执行过程：先判断条件语句是否是true（若果不是布尔值，就转化为布尔值再判断），如果为true就执行if语句的代码块，否则不执行

  2. if双分支结构

    1. age = int(input('请输入您的你年龄:'))
    2. if age <= 18:
    3.     # 缩进-indent
    4.     print('未成年')
    5. else: # 无条件执行
    6.     print('成年人')  # else可以有，可以没有，但是最多有一个,

  3. if多分支

    1. weight = float(input('请输入您的体重(kg):'))
    2. height = float(input('请输入您的身高(m):'))
    3. # 计算bmi
    4. bmi = weight/height**2
    5. print('您的bmi指数是%.1f'%bmi)
    6. if bmi<18.5:
    7.     print('太瘦')
    8. elif bmi<25:
    9.     print('正常')
    10. elif bmi<28:
    11.     print('微胖')
    12. elif bmi<32:
    13.     print('肥胖')
    14. else:
    15.     print('死肥宅')

    多分支，即有多个选择判断，使用elif 条件语句：，最后面的else 可有可无。

循环示意图：

又称：循环 迭代，遍历

遍历操作，以此从集合容器中取每个值

循环格式：

  1. # for 临时变量 in 字符串，列表等：
  2. #     执行代码块

举例

  1. # 求100之内数和
  2. sum = 0  # 定一个初始变量 ，用于存放累加和
  3. for data in range(1,101):   # 使用range函数创建一个顺序的集合，range(1,101)1代表从1开始，101代表索引即下标为101的元素，代表是100这个元素
  4.     sum = sum + data  # 每次累加，
  5. print(f'--{sum}')  # 打印输出
  1. # 输出100以内的偶数和奇数
  2. for i in range(1, 101):  
  3.     if i % 2 == 0:         # 判断是否能被2整除，即为偶数
  4.         print(f'是偶数{i}')
  5.     else:                  # 其他就是奇数
  6.         print(f'是奇数{i}')

案例—-登录判断用户和密码，限定用户输入次数。for 与else 联合使用

  1. '''
  2.  案例，限定用户登陆的次数，一旦三次没有登录成功就提示用户已被锁定
  3.  思路：  用for循环控制尝试登陆的次数，执行完整个for循环没有登录成功则锁定账户
  4.  所采用的结构：
  5.  for 变量 in 遍历对象：
  6.     执行代码块
  7.  else:
  8.     循环执行结束后,要执行的内容
  9. '''
  10. username = 'admin'
  11. userpassword = '123456'
  12. for i in range(1, 4):
  13.     a = input('请输入用户名：')
  14.     b = input('请输入密码：')
  15.     if a == username and b == userpassword:  # 与默认值对比，正确登陆成功，跳出循环，反之继续循环直至结束
  16.         print(f'欢迎{a}登录成功')
  17.         break
  18.     else:  # 反之提示输入错误，
  19.         print(f'密码或账户错误，失败请重新输入')  # 循环直至循环结结束
  20. else:  # 在循环中使用else 即当循环结束，打印输出以下语句
  21.     print('密码或者账户输入错误三次，账户已锁定，请联系管理员')

注意：只要循环语句中break语句没有执行，else就会执行 ，也是break与else使用。

image-20220402123409839

重复执行某一段代码，当达到循环条件时，结束循环。

格式：

  1. # 1. 设置循环结束条件
  2. # 2. 书写循环条件判断条件
  3. while 判断条件:
  4. # 3. 需要重复执行的代码
  5. # 4. 改变循环的初始条件(计数器)
  6. # 1. while 是关键字

举例：

  1. '''
  2. while循环
  3. '''
  4. s = 0
  5. i = 1
  6. while i<=10: # 只要条件满足，就执行循环体
  7.     s = s + i
  8.     i = i + 1
  9. print(s,i)
  • for循环已知循环次数，
  • while循环不知道循环的次数，只有循环条件
  1. for i in range(1,11):  # 定义一个集合
  2.     if i ==4:          # 判断当i =4 跳出循环
  3.         break
  4.     print(i)           # 此时还在for中执行打印输出循环次数 
  1. for i in range(1, 11):
  2.     if i == 5:
  3.         continue      # 跳过此次循环，不计入打印
  4.     print(i)

简单讲就是讲代码封装起来，方便使用，函数就是‘洗衣机’ , 定义函数就是‘准备装洗衣机’ , 调用就是 ‘ 用洗衣机 ’, 函数注释就是 ‘ 洗衣机说明书 ’ , return 返回值就是 ‘ 拿出洗完的衣服 ’。

  1. # def 函数名(参数名1, 参数名2) :
  2. # ''' 函数注释 '''
  3. # 函数体代码
  4. # return 返回值
  • 函数的定义
    • 函数必须先定义后调用
    • 函数在定义阶段只检测语法不执行语法，简单讲就是自检，不执行输出
    • 函数只有在调用阶段才会执行函数体代码
  • 函数调用
    • 函数名加括号
    • 定义时有参数，需要传参

image

image

内置函数

  • python解释器自带的函数

自定义函数

  • 有参函数
  • 无参函数
  • 空函数
  • 函数一定要有返回值，如果不显示指明返回值，则默认返回None
  • return语句只能返回一个值，如果试图返回多个值，会自动打包成一个元组
  1. '''
  2. 位置参数：positional argument
  3.         -必须传参
  4.         -传入的实参按照顺序(位置)传递给形参， 不能多，不能少
  6. 默认参数: default parameter
  7.         -有默认值的参数
  8.         -可以极大的降低调用函数的难度
  9.         -默认参数必须放在位置参数的后面
  10.         -默认参数可以按照顺序传参， 但如果不按照顺序传参，则必须指明参数名称
  12. 可变参数：
  13.         -实参的多少不固定，形参前面有一个*， 星号的作用是将传入的所有实参封装为一个元组
  14.         *在实参的前面表示拆包，*在形参的前面表示打包
  15.         -可变参数允许传入0个或多个实参
  16.         -一个函数中最多有一个可变参数，也可以没有
  18. 关键字参数：keyword arguments
  19.         -形参的前面有2个星号： **， 将传入的所有参数封装为一个字典
  20.         -关键字参数允许传入0个或多个包含参数名的参数
  21.         -可以扩展函数的功能
  22.         -一个函数中最多有一个关键字参数，也可以没有
  24. 命名关键字参数：keyword-only argument
  25.         -命名关键字参数必须写在 一个单独的 * 号的后面
  26.         -命名关键字参数如果放在可变参数的后面，可以省略 *
  27.         -命名关键字参数必须给值，除非已经有默认值了
  29. '''
位置参数：
  1. # 一个参数  求数的平方
  2. def sss(x):
  3.     return x * x
  6. print(sss(10))
  7. print('------')
  9. # 两个参数 求数任意次方
  10. def ddd(x, y):
  11.     return x ** y
  14. print(ddd(10, 20))
默认参数：
  1. def sqere(x, y=2):
  2.     return x + y
  5. # 因为有默认的值，在传参数的时候，可以直接使用默认的
  6. print(sqere(10))
  7. # 也可以同时传参，将默认的值替换了
  8. print(sqere(10, 3))
可变参数：
  1. def sum(*data):
  2.     print(data)
  3.     s = 0
  4.     for i in data:
  5.         s = s + i
  6.     return s
  9. # 直接将多参数传给函数
  10. r = sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  11. print(f'r={r}')
  12. # 定义一个列表存放传参
  13. data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  14. # 与函数中参数要相同
  15. r = sum(*data)
  16. print(f'r={r}')
关键字参数：
  1. def info(name, age, gender='男', city='西安', **kw):
  2.     print(name, age, gender, city, kw)
  4. info('tom', 20, '男', '北京')
  5. info('tom', 20, '男', '北京', marrige='否', car='BBA', house='200')
命名关键字参数：
  1. def info(name, age, gender='男', city='西安', *, hobby, education='本科'):
  2.     print(name, age, gender, city, hobby, education)
  3. # info('tom', 20, '男', '北京', marrige='否', car='BBA', house='200')
  4. info('tom', 20, '男', '北京', hobby='游戏', education='本科')
  5. info('tom', 20, '男', '北京', hobby='游戏')
多种参数同时使用：
  1. def funtion(a,b,c=2,d='tom',*e, f,g,**h):
  2.     print(a,b,c,d,e,f,g,h)
  3. # 分析，a,b，为位置参数，c为默认参数，形参中*e代表可变参数，形参**h为关键字参数
  4. funtion(1,20,3,'mike',3,6,9,f=100, g=200, marrige='否', car='BBA', house='200')
  6. def funtion(*args, **kw):
  7.     print(args, kw)
  8. # 前面到9，都是可变参数，因为后面是直接定义参数赋值，归到命名关键字参数
  9. funtion(1,20,3,'mike',3,6,9,f=100, g=200, marrige='否', car='BBA', house='200')

函数在运行过程中，直接和间接调用自身

特点：

  • 必须有一个结束条件
  • 每一次递归都必须离结果更进一步
  • 通常前一次的输出作为下一次输入
  • 没有结束条件，递归次数过多导出内存溢出，即报错
  1. '''
  2. 5! = 5*4*3*2*1 = 5*4! = 5*(5-1)!
  3. 4! = 4*3!
  4. 3！= 3*2！
  5. 2！= 2*1！
  6. 1！= 1
  8. '''
  11. # 得出规律 n! = n* (n-1)!
  13. def f(n):  # 定义函数
  14.     if n == 1:  # 结束条件-边界值条件
  15.         return 1
  16.     return n * f(n - 1)  # 返回值对自身调用
  19. print(f(5))

全局变量

  • 整个模块

局部变量

  • 定义变量的函数或方法

成员变量/实例变量

  • 定义变量的实例中：构造方法__init__()中定义的,通过 self 参数引用;

类变量

  • 定义变量的类中，在对象/类中，不在对象/类的函数中

总结：Python中变量的区别就是作用域不同，作用域越小的变量，优先级越高

  1. # 局部变量和全局变量
  2. #	python中数据有类型，变量没有
  3. #	变量之间唯一区别就是变量的作用域不同
  4. #		全局变量-作用域是整个模块
  5. #		局部变量-作用域在定义函数之中
  6. #   局部变量的优先级高于全部变量 
  7. #	优先使用局部变量，一般不要使用全局变量
  8. #成员变量/实例变量
  9. #	作用域在定义变量的实例中
  10. #类变量
  11. #	定义变量的类中
  12. a = 10  # 全局变量 - 作用域是整个模块
  13. print(a)
  15. def f(x):
  16.     b = "5" # 局部变量 - 作用域是在定义它的函数之中- 局部变量的优先级高于全局变量
  17.     print(b)
  18.     global a # 声明a是一个全局变量
  19.     a = 8
  20.     print(f'a1={a}')
  22. f(4)
  23. # print(b)
  24. def m():
  25.     b = 9
  26.     print(f'a2={a}')
  28. m()
  30. class F():
  31.     clazz = 56 # 类变量
  32.     def __init__(self, v3)
  33.     v1 = 10 # 局部变量
  34.     self.v3 = v3 # 成员变量/实例变量

切片顾名思义及把列表切开分成不同的部分

注意：

  • 切片操作产生一个新的列表
  • 切片操作可以用于列表、元组、字符串
  1. '''
  2. 切片
  3.     切片操作产生一个新的列表
  4.     因为切片操作适用于列表，元组，字符串
  5. '''
  7. names = ['王海', '骆纯', '李宁', '赵艳芳', '任收港', '李颖']
  9. m = [names[0], names[1], names[2]]
  10. print(m)
  11. m = names[1:3] # 包含前面的索引，不不包含后面的索引
  12. print(m)
  13. m = names[2:] # 截取到末尾
  14. print(m)
  15. m = names[:4] # 从头开始截取
  16. print(m)
  17. m = names[:] # 复制列表
  18. print(m)
  19. print(id(m))
  20. print(id(names))
  21. # id()查看内存地址
  22. n = names
  23. print(n.pop())
  24. print(id(n))
  25. print(id(names))
  27. o = names[::2] # 步长默认是1，也就是说：：后面接步长
  28. print(o)
  1. t2 = (i for i in range(100))  # 元组()
  2. print(t2)  # 此时打印的这个对象的地址
  3. print(tuple(t2))  # 将对象转化为元组
  4. # 列表和字典无需转化
  5. t3 = [i for i in range(10)]  # 创建一个列表 []
  6. print(t3)
  7. t4 = {i for i in range(100)}  # 字典表达式 {}
  8. print(t4)

生成式：元组特殊需要对其tuple转化，其余[列表]和{字典}

​ 在不改变函数原有代码的情况下，增强函数的功能

​ 装饰器本质上是一个高阶函数

image

  1. '''
  2. 装饰器
  3. 	作用：
  4.     在不改变函数原有代码的情况下，增强函数的功能
  5.     原理：
  6.     装饰器本质上是一个高阶函数，传入一个函数作为参数，然后返回一个新的函数
  7. '''
  9. import time
  12. def log(func):  #
  13.     def wrapper(*args, **kw):
  14.         print(f'正在执行函数{func.__name__}:')
  15.         return func(*args, **kw)
  17.     return wrapper
  20. def service(func):
  21.     print(f'正在执行函数{func.__name__}:')
  24. @log  # now = log(now)  # 调用这个函数@函数名
  25. def now():
  26.     # print(f'正在执行函数-{now.__name__}:')
  27.     # service(now)
  28.     print(time.strftime('%Y/%m/%d %H:%M:%S'))
  31. now()
  34. def f():
  35.     print(f'正在执行函数{f.__name__}:')
  36.     # service(f)
  37.     pass
  40. # 此处是直接调用函数中的函数
  41. # f = log(f)
  44. @log  # g=log(g)
  45. def g():
  46.     # print(f'正在执行函数{g.__name__}:')
  47.     # service(g)
  48.     pass
  51. f()
  52. g()

对于修饰器来讲最主要的是会调用，及@函数名，与运行函数的调用。

  • 函数名就是一个变量，这个变量指向了函数对象本身
    • 如果一个函数f接收了另一个函数g作为参数，那么我们就把函数f称为-高阶函数
    • 如果一个函数f返回了另一个函数g作为返回值，那么我们就把函数f称为-高阶函数
  • 闭包：内部函数引用外部函数
  1. def g(x):  # 参数函数
  2.     return x * x
  4. x = 3
  6. # 函数作为参数
  7. def f(x, g):  # g代表上面的函数
  8.     return g(x) + g(x)
  10. print(f(x, abs))
  11. print(f(-3, abs))
  12. print(f(-3, g))
  14. # 函数作为返回值
  15. def sum(*args):
  16.     def ss():
  17.         s = 0
  18.         for i in args:
  19.             s = s + i
  20.         return s
  21.     return ss  # 返回值为函数
  23. r = sum(1, 4, 7, 9, 10, 22)
  24. print(f'r={r}')  # 打印功能地址
  25. print(f'r={r()}')  # 调用函数输出

匿名函数及lambda表达式，

  • 匿名函数及没有名字，
  • 通常用于判断或者计算
  • 函数的输入值为参数，输出值由表达式计算出来
  1. # 匿名函数-lambda表达式,默认有一个return,将表达式的结果返回
  2. r = map(lambda x:x*x,[1,2,3,4,5]) # 匿名函数求列表阶乘
  3. print(list(r))  # 将map转化list 
  5. ff = lambda x:x*x
  6. print(ff(4))
  7. # 举例
  8. print('---利用map函数将字符串首字母变为大写,其余字母小写（使用lambda表达式）---')
  9. a = ['tom', 'MIKE', 'Tony']
  10. # 定义一个变量，先将列表转化为map函数，在使用匿名函数，
  11. # 对列表中元素操作调用map函数的方法capitalize首字母大写，最后对结果强制转为list
  12. # lamba函数格式：lamba  变量：操作 ，变量
  14. list_name = list(map(lambda a: a.capitalize(), a))
  15. print(list_name) 
  17. # s:s[0]获取下标为0的元素，调用函数upper转化大写，+ 拼接字符串s[1:]从下标为1开始直至结束，使用函数lower()转化为小写，m代表
  18. list1 = map(lambda a: a[0].upper() + a[1:].lower(), a)
  19. print(list(list1))

模块
一个.py文件就是一个模块(module)
-提高代码的可维护性
-方便代码复用
-避免函数名和变量名冲突

包
一个包含__init__.py模块的文件夹就是一个包(package)
-避免模块名冲突
-方便代码管理

  1. # 自定义模块
  2. # import demo19_装饰器
  3. from demo19_装饰器 import log
  4. from ppp.demo import ddd
  6. # 系统模块
  7. import time
  8. import sys
  11. # 第三方模块
  12. # pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/ - 设置镜像
  13. # pip list - 查看已安装模块
  14. # pip install requests - 安装模块
  15. # pip uninstall requests - 卸载模块

面向对象编程

面向过程，函数是核心

面向对象

Class：类

​ 类名首字母一般大写

​ 写的类都是自定义类型

object：（对象）object是所有类的父类，默认继承object，可以省略不写

self.name 成员变量

面向对象编程三大特点

  1. 封装：将数据和处理数据的方法都封装在对象中
  2. 继承：当我们定义一个类的时候，都可以从某个现有的类继承，新的类称为子类(Subclass)，
    被继承的类称为父类(基类，超类SuperClass)，通过继承，子类可以获取父类的全部功能
  3. 多态：一个对象既是子类的实例，也是父类的实例
  1. class Person:  # 创建父类
  2.     def __init__(self, name, age):  # 定义成员变量
  3.         self.name = name
  4.         self.age = age
  6.     def talk(self):  # 定义成员方法
  7.         print(f'{self.name}正在大声的说废话...')
  8. class Worker(Person):  # 继承
  10.     def __init__(self, name, age, position):  # 成员变量
  11.         super().__init__(name, age)  # 调用父类的初始化方法
  12.         self.position = position  # 创建子类独有的成员变量
  13.     # 方法重写-子类和父类存在同名方法时，子类的方法会覆盖父类的方法
  14.     def talk(self):
  15.         # super().talk()
  16.         print(f'{self.position}{self.name}正在大声的讨论技术...')
  17. # 实例化
  18. #     创建某一个类的具体的一个对象的过程，称为实例化instanciate，
  19. #     创建出来的对象也称为实例instance
  20. # w = Worker('jonny', 30)
  21. w = Worker('jonny', 30, '高工')  # 创建工人对象实例
  22. w.talk()  # 调用子类重写父类的方法
  • try：
    • 可能出问题的代码，必须要有，但是只能有一个
  • except：
    • 捕捉异常，发生异常时才执行，可以有，也可以没有，也可以最多有一个
    • 当多个except语句时，小类型一定要放在大类型的前面
  • finally
    • 一定要执行的代码放在这里，可以有，也可以没有，但是最多有一个
  • breakpoint：断点
  1. try:
  2.     n = int(input('请输入一个整数：'))
  3.     a = 0
  4.     print(n,a)
  5.     r = n/a
  6.     print(f'r={r}')
  7. # except ZeroDivisionError as e: # 捕捉异常
  8. #     print(f'ZeroDivisionError:{e}')
  9. # except TypeError as e:
  10. #     print(f'TypeError:{e}')
  11. # except Exception as e:
  12. #     print(f'Exception:{e}')
  13. finally:
  14.     print('--OVER--')
  16. print('--搞定收工--')

Input/Output

​ 读(输入)：从硬盘到内存

​ 写(输出)：从内存到硬盘

读文件：

  • r：read
  • encoding：编码方式，默认是gbk

对文件或者其他类型的文件时，都需要异常的处理，在对于文件操作时，使用以下格式

  1. with open(r'.\demo.txt', 'r', encoding='utf-8') as f:
  2.     # read:读取文件的全部内容
  3.     # read(n): 读取指定个数的字符
  4.     # readline: 按行读取
  5.     # readlines(): 读取所有的行
  6.     r = f.readlines()
  7.     print(r)
  9. '''
  10. 写文件
  11.     写的时候，如果文件不存在，则会创建一个新文件
  12.     w: write,覆盖写
  13.     a: append，追加写
  14. '''
  15. with open('demo.txt', 'a', encoding='utf-8') as f:
  16.     f.write('\n上海疫情失控。')
  17. '''
  18.     : binary 二进制
  19. '''
  20. with open('demo.txt', 'wb') as f:
  21.     r = f.read()
  22.     print(r)
  23. with open(r'D:\workspase\20190115-5.jpg', 'rb') as d:
  24.     # 打开被复制的图片，需要rb
  25.     # 读取图片
  26.     data = d.read()
  27.     print(data)
  28.     # 关闭
  29.     d.close()
  30. with open(r'.\20220407.jpg', 'wb') as s:
  31.     new_data = s.write(data)
  32.     s.close()
  1. '''
  2. 字符串
  3. '''
  4. import re
  6. # 字符串切片
  7. s = 'abcdefg'
  8. print(s[:3])  # 切到 d(不包含d) 使用下标
  9. index = s.index('d')  # 切到 d(不包含d) 指定元素
  10. print(s[:index])
  12. s = ' tom, mike, jerry\n '
  13. '''
  14. split:
  15.     按照指定字符进行切分，并将切分的结果以列表的形式返回
  16. strip:
  17.     去除字符串前后多余的空白字符
  18. '''
  19. # r = s.split(',', 1)
  20. r = s.split(',')
  21. print(r)
  22. # 遍历元素按，分割字符串，去掉空白字符
  23. r = [i.strip() for i in r]
  24. # 列表生成式
  25. r = [i.strip() for i in s.split(',')]
  26. print(r)
  28. a = ' abc\n '
  29. print(a)
  30. print(a.strip())
  32. '''
  33. 正则表达式
  34. '''
  35. # 因为有边界值，当前面有空格，会选择一个空格
  36. r = re.split(r'\s+', s)
  37. print(r)
  1. 导入数据包，import mysql.connector
  2. 连接数据库：
  3. 获取游标(操作数据的对象)：cursor = db.cursor()
  4. 操作数据：cursor.execute(‘sql操作语句’)
  5. 提交事务：mysqldb.commit()
  6. 关闭连接：mysqldb.close
  1. # 连接数据库
  2. db = mysql.connector.connect(host='localhost',
  3.                              port=3306,
  4.                              user='root',
  5.                              password='123456',
  6.                              database='demo')  # 指定数据库
  7. # 创建游标
  8. cursor = mysqldb.cursor()
  9. # 操作数据
  10. # 	创建数据库
  11. cursor.execute('CREATE DATABASE demo CHARACTER SET "utf8";')
  12. # 更新数据
  13. cursor.execute("UPDATE USER SET age = %s WHERE id =%s;",(age,id))
  14. # 提交事务
  15. '''事务
  16.     将一系列可以看做一个整体的操作称为一个事务
  17.     提交commit  - 如果事务执行成功，则提交，让改动永久生效
  18.     回滚rollback- 如果事务执行失败，则回滚，撤销之前的操作
  19. A 原子性
  20. C 一致性
  21. I 隔离性
  22. D 持久性
  23. '''
  24. mysqldb.commit()
  25. # 关闭连接
  26. mysqldb.close
  27. # 查询数据
  28. cursor.execute('select * from user')
  30. # 获取查询的结果
  31. result = cursor.fetchall()  # 查询使用游标的fetchall方法，查询结果为一个列表包含元组
  32. print(result)

ORM对象关系映射

将数据的数据映射到代码对象中，主要为了查询结果

  1. # 获取查询的结果
  2. result = cursor.fetchall()
  3. # 创建对象
  4. class User: 
  6.     def __init__(self, id, name, age):
  7.         self.id = id
  8.         self.name = name
  9.         self.age = age
  10. # 将查询结果给他对象实例化
  11. user1 = User(result[0][0],result[0][1],result[0][2])
  12. # 使用for循环遍历结果将数据放到对象中
  13. users = []
  14. for idd, name, age in result:
  15.     print(idd, name, age)
  16.     users.append(User(idd, name, age))
  18. print(users)
  19. # 查看对象内存地址
  20. print(hex(id(users[0])))
  1. class Demo:
  2.     clazz = 88
  4.     def __init__(self, name):
  5.         self.name = name
  7.     # 实例方法 - 通过实例对象调用
  8.     def f(self):
  9.         print(self.name)
  11.     # 静态方法 - 可以用实例进行调用，也可以直接使用类名进行调用（推荐）
  12.     @staticmethod
  13.     def m():
  14.         print('好好学习，天天向上')
  16.     # 类方法 - 可以用实例进行调用，也可以直接使用类名进行调用（推荐）
  17.     @classmethod
  18.     def n(cls):  # cls代表当前类对象
  19.         print(cls.clazz)
  21. d = Demo('tom')
  22. d.f()
  23. d.m()
  24. Demo('mike').m() # 当通过对象调用对象的方法时，因为对象有实例方法，需要传参
  25. Demo.m()
  26. Demo.n()
  27. d.n()
版权声明：本文为枯树老鸭原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/kushulaoya/p/16196250.html