安装 Pycharm 和配置环境

  • 去官网下载,我下载的是 2021版本
  • 安装步骤
  • 安装完开始破解啦(书签里有工具和教程),破解完成如图:

Python解释器安装

注意:有两种解释器可以选择

一个是普通没有集成库(需要手动下载)的 python解释器

一个是已经集成了很多库的 Anaconda 解释器

安装哪个都可以,看选择下面都有介绍安装过程

python 解释器

  • 一定要选择这个不要点其他类型(他喵不然配置环境变量时你找不到 Scripts 文件夹)

  • 按下面步骤安装
  • 检查环境变量配置了没,但是还是谨慎点好

如果没则需要去安装路径找

  • 打开 Pycharm

  • 创建新项目,可以用快捷键 【ALT】+【INS】

Anacinda 解释器

官网:Anaconda

  • 安装完成可以去 Pycharm 里替换现在这个解释器了(注意:如果安装完成没看到有 python.exe 可能就是你的盘符内存不足,刚刚安装时没装上,至少要5G以上内存)

好用插件+背景图片设置

  • 插件1:Chinese(汉化工具)

  • 插件2:Translation(中英互译,看文档必备)
  • 插件3:AiXcoder Code Completer(代码补全,新手建议还是自己敲)

  • 插件4:Rainbow Brackets(括号显示不同颜色,好分辨)

  • 插件5:Indent Rainbow(对于不同层级缩进的空格标注不同的颜色)

  • 插件6:CodeGlance(在IDE的最右侧生成一条工具栏)

  • 插件7: CSV(用于编辑CSV/TSV/PSV文件,语法验证,结构高亮,可定制着色)

  • 插件8:Key Promoter X(学习IDE快捷键必备)

  • 背景设置
  • 这敲起代码都有劲呢!

  • 字体也可以改,找到 Pycharm安装路径,点击【jbr】->【lib】->【fonts】文件下,把你的 .ttf 字体文件粘贴过去即可

安装外部库

  • 打开电脑【cmd】安装即可
  • 但是这种安装外部库一般都很慢,因为站点是在国外的,所以可以通过国内的镜像源站点来下载,速度杠杠的!

清华镜像https://pypi.tuna.tsinghua.edu.cn/simple/

豆瓣镜像http://pypi.douban.com/simple/

阿里云https://mirrors.aliyun.com/pypi/simple/

命令格式

pip install 库名 -i 镜像地址

python前言

解释器

计算机不能直接理解任何除机器语言以外的语言,必须要把程序语言翻译成机器语言,计算机才能执行程序。

编译器:将其他语言翻译成机器语言的工具(编译器翻译方式:编译,解释)

两种方式的区别在于翻译时间点的不同。当编译器以解释方式运行的时候,也称之为解释器

  • 编译型语言:程序执行之前需要有一个专门的编译过程,把程序编译成为机器语言的文件,运行时不需要重新翻译,直接使用编译的结果就行了。程序执行效率高,依赖编译器,跨平台性差些。

  • 解释型语言:解释型语言编写的程序不进行预先编译,以文本方式存储程序代码,会将代码一句一句直接运行。在发布程序时,看起来省了道编译工序,但是在运行程序的时候,必须先解释再运行

  • 速度:编译比解释型快

python特点

  • 完全面向对象的语言
  • 拥有一个强大的标准库
  • 有大量的第三方模块

面向对象的思维方式

  • 面向对象 是一种 思维方式,也是一门 程序设计技术
  • 要解决一个问题前,首先考虑 由谁 来做,怎么做事情是 的职责,最后把事情做好就行!对象 就是
  • 要解决复杂的问题,就可以找多个不同的对象,各司其职,共同实现,最终完成需求
  • 先找一个可以完成功能的对象,并且使用对象所提供的能力来解决问题

python优缺点

优点

  • 简单、易学

  • 免费、开源

  • 面向对象

  • 丰富的库

  • 可扩展性

    如果需要一段关键代码运行得更快或者希望某些算法不公开,可以把这部分程序用 CC++ 编写,然后在 Python 程序中使用它们

缺点

  • 运行速度差一点
  • 国内市场较小
  • 中文资料匮乏

执行 python 程序的三种方式

  • 解释器 — python / python3
  • 交互式 — ipython
  • 集成开发环境 — Pycharm

文件扩展名通常是 .py

python 的运行方式

Python 的解释器

# 使用 python 2.x 解释器
$ python xxx.py
# 使用 ptyhon 3.x 解释器
$ python3 xxx.py

python基础知识

注释

  • 单行注释:以 # 开头,后面加一个 空格
  • 多行注释:用一对连续的 三个引号 即可(单,双引号均可)
# 这是一条注释
'''
这是
多行
注释
'''

行与缩进

  • python 与其他语言明显的区别是没有大括号,而是用缩进表示代码块
  • 需要注意的是每行代码语句不需要以 ; 结尾(学过C语言的注意一下)
  • 注意:Python字符串不是通过 NUL(‘\0’)来结束,其字符串值只包含所定义的内容

变量的输入

  • 在 Python 中可以使用 input 函数从键盘等待用户输入
  • 用户输入的任何内容 Python 都认为是一个字符串
# 语法
s = input("请输入:")
print("你输入了:"+s)

变量的格式化输出

  • % 被称为格式化操作符,专门用于处理字符串中的格式
  • 包含 % 的字符串,被称为格式化字串符
  • %不同的字符连用,不同类型的数据需要使用不同的格式化字符

# 语法
a1 = "1"
a2 = "2"
num1 = 3.14
num2 = 12
num3 = 3
print("%s+%s=3" % (a1, a2))  # 1+2=3
print("%s==1" % a1)  # 1==1
print("%s!=%f" % (a1, num1))  # 1!=3.140000
print("%d*%d" % (num2, num3))  # 12*3

变量的命名规则

注意 Python 中的 标识符 区分大小写的

  • 在定义变量时,为了保证代码格式,= 的左右应该各保留一个空格

  • Python 中,如果 变量名 需要由 二个 或 多个单词 组成时,可以按照以下方式命名:

    每个单词都使用小写字母
    小驼峰式命名法(第一个单词以小写字母开始,后续单词的首字母大写)
    大驼峰式命名法(每一个单词的首字母都采用大写字母)

变量的进阶

  • 变量和数据 都是保存在 内存 中的

  • Python函数参数传递 以及 返回值 都是靠 引用 传递的

  • 引用的概念:

    变量数据分开存储的

    数据 保存在内存中的一个位置

    变量 中保存着数据在内存中的地址

    变量记录数据的地址,即 引用

    使用 id() 函数查看变量中保存数据所在的 内存地址

注意:若变量已被定义,当给一个变量赋值的时候,本质上是 修改了数据的引用

变量 不再 对之前的数据引用

变量 改为 对新赋值的数据引用

  • Python 中,函数的 实参/返回值 都是是靠 引用 来传递来的

可变和不可变类型

  • 不可变类型,内存中的数据不允许被修改:

    数字类型 int, bool, float, complex, long(2.x)

    字符串 str

    元组 tuple

  • 可变类型,内存中的数据可以被修改:

    列表 list

    字典 dict

注意:字典的 key 只能使用不可变类型的数据

可变类型的数据变化,是通过 方法 来实现的

若给一个可变类型的变量,赋值了一个新的数据,引用会修改

  • 变量 不再 对之前的数据引用
  • 变量 改为 对新赋值的数据引用

哈希(hash)

  • Python 中内置有一个名字叫做 hash(o) 的函数,接收一个 不可变类型 的数据作为 参数返回 结果是一个 整数
  • 哈希 是一种 算法,其作用就是提取数据的 特征码(指纹)
    相同的内容 得到 相同的结果
    不同的内容 得到 不同的结果
  • Python 中,设置字典的 键值对 时,会首先对 key 进行 hash 已决定如何在内存中保存字典的数据,以方便 后续 对字典的操作:增、删、改、查
  • key 必须是不可变类型数据 value 可以是任意类型的数据

局部变量和全局变量

  • 不同的函数,可以定义相同的名字的局部变量,但是 彼此之间 不会产生影响,局部变量在函数执行时才会被创建函数执行结束后,局部变量会被系统回收

注意:函数执行时,需要处理变量时 会:

首先 查找 函数内部 是否存在 指定名称局部变量如果有,直接使用

若没有,查找 函数外部 是否存在 指定名称全局变量如果有,直接使用

若还没有,程序报错!

  • 函数不能直接修改 全局变量的引用

    全局变量 是在 函数外部定义 的变量(没有定义在某一个函数内),所有函数 内部 都可以使用这个变量

    在函数内部,可以 通过全局变量的引用获取对应的数据

    但是,不允许直接修改全局变量的引用 —— 使用赋值语句修改全局变量的值

注意:注:只是在函数内部定义了一个局部变量而已,只是变量名相同 —— 在函数内部不能直接修改全局变量的值

  • 若在函数中需要修改全局变量,需要使用 global 进行声明
  • 全局变量定义的位置定义在其他函数的上方
  • global 需要在函数内部声明
def fun():
    global a
    a = 99


a = 4
b = 6
fun()
print(a)  # 99

算术运算符

  • 在 Python 中 * 还可以用于字符串,结果是字符串重复指定次数的结果
  • Python 2.x 中判断 不等于 还可以使用 <> 运算符; != 在 Python 2.x 中同样可以用来判断 不等于

逻辑运算符

赋值运算符

  • 赋值运算符中间不能使用空格

运算符的优先级

sort 与 sorted 区别

  • sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作
  • list 的 sort 方法返回的是对已经存在的列表进行操作无返回值
  • 内建函数 sorted 方法返回的是一个新的 list而不是在原来的基础上进行的操作

print 函数

  • 在默认情况下,print 函数输出内容之后,会自动在内容末尾增加换行
  • 如果不希望末尾增加换行,可以在 print 函数输出内容的后面增加 , end=""
  • 其中 "" 中间可以指定 print 函数输出内容之后,继续希望显示的内容
  • 语法格式如下:
# 不会换行
print("123", end="")
# 单纯换行
print("")

公共方法

  • 运算符

  • 成员运算符

in 在对 字典 操作时,判断的是 字典的键

innot in 被称为 成员运算符

常见关键字

Python一共33个关键字

常用的关键字用法与注意事项

  • del

使用 del 关键字(delete) 同样可以删除列表中元素

del 关键字本质上是用来 将一个变量从内存中删除的

如果使用 del 关键字将变量从内存中删除,后续的代码就不能再使用这个变量了

del list1[1]
  • as

with...as... ,主要用于文件的读写操作,省去关闭文件的麻烦

导入模块起别名 ,对导入的模块进行重命名,或者导入函数对函数重命名

将捕获到的异常对象赋值给 except

数据类型

  • Python 中数据类型可以分为 数字型非数字型
  • 数字型

整型(int),浮点型(float),布尔型(bool),复数型(complex

  • 非数字型

字符串,列表,元组,字典

  • 在 Python 中,所有 非数字型变量 都支持以下特点

① 都是一个 序列sequence),也可以理解为 容器

② 取值([]

③ 遍历(for in

④ 计算长度,最大/最小值,比较,删除

⑤ 链接(+)和 重复(*

⑥ 切片

整数类型

  • 与数学中的整数概念一样,没有取值范围限制
  • 一共有4种进制表示,默认十进制,其他进制需要增加引导符(不区分大小写)
  • 二进制:0b 或者 0B 八进制:0o 或者 0O 十六进制:0x 或者 0X

浮点数类型

  • 浮点数类型与数学中实数的概念一样,表示带有小数的数值。必须有小数部分,小数部分可以是0
  • 浮点数两种表示方式:十进制(10.0),科学计数法(1.01e3)

复数类型

  • Python 语言中,复数可以看做是二元有序实数对(相当于坐标吧),(a,b) 表示 a+bj ,其中,a 是实数部分,b 是虚数部分
  • z = 1.23e-4+5.6e+89j,对于复数 z,可以用 z.real 获取实数部分,z.imag 获取虚数部分
z = 12-3j
a = z.real
b = z.imag
print(a, b)  # a = 12.0  b = -3.0

数字类型的运算

# 取商的整数部分,与浮点数运算结果也是浮点数
print(1010.0//3)  # 336.0
# ** 幂运算
print(2**3)  # 8
# 整数或浮点数与复数运算,结果是复数
print(10 - (1+1j))  # (9-1j)
# 绝对值
print(abs(-9))  # 9
# 把除数和余数运算结果结合起来,返回一个包含商和余数的元组
print(divmod(8, 2))  # (4,0)
# 也是幂运算
print(pow(3, 2))  # 9
# 对参数1四舍五入,参数2是保留多少位小数可省略
print(round(6.111, 2))  # 6.11
# 取最大值,没有限定多少个
print(max(1, 2, 3, 4, 5, 6, 7))  # 7
# 取最小值
print(min(1.2, -2, 0, 3))  # -2

字符串类型

  • 根据字符串的内容多少分为单行字符串多行字符串
  • 单行字符串由 ' ' 或者 " " 括起来
  • 多行字符串可以由一对三单引号 ''' 或者三单双引号 """ 括起来
  • 转义字符用 \ 表示,例如:
\n # 表示换行
\\ # 表示反斜杠
\' # 表示单引号
\" # 表示双引号
\t # 表示Tab键
\r # 表示回车
  • 字符串的索引

s = "你是傻逼吗?"
print(s[0])  # 表示第0个字符
  • 字符串的切片(对字符串中某个子串或区间的检索)
s = "你是傻逼吗?"
# s[n:m]取值方式左到右,n从0开始,m是列表元素索引值减1
# n始终比m小(n,m可以是正数,0,负数)
# 记忆法:从列表s的第n个元素开始,取出来m-n个元素
# n和m都可以同时缺省表示输出整个字串符(m可以超出字串符数量也不会报错)
# 后面数-1开始
# 步长默认是1
print(s[0:6])  # 你是傻逼吗?
print(s[-1])  # ?
  • 高级用法【步长】(切片截取的内容不包含结束下标对应的数据,步长指的是隔几个下标获取一个字符
# 每隔2个取值
print(s[1:6:2])  # 是逼?
print(s[::2])  # 你傻吗

  • 字符串操作符

# 连接两个字符串
s = "锄禾日当午"
s2 = "汗滴禾下土"
s3 = "锄禾日当午"
print(s+s2)  # 锄禾日当午汗滴禾下土
# 复制n次字符串x
print(s*2)  # 锄禾日当午锄禾日当午
# 如果x是s的子串返回True,否则返回False
print(s2 in s)  # False
print(s3 in s)  # True
  • 字符串处理函数
s = "锄禾日当午"
# 返回字符串长度
print(len(s))  # 5
# 任意类型x所对应的字符串形式
a = str(123)
print(a)  # 123
# type函数返回变量的数据类型
print(type(a))  # <class 'str'>
# 整数x的十六进制或八进制小写形式字符串
num = 12345
print(hex(num))  # 0x3039
print(oct(num))  # 0o30071
# x为Unicode编码,返回其对应的ASCII字符
print(chr(65))  # A
# x为字符,返回其对应的Unicode编码
print(ord('A'))  # 65
  • 字符串处理方法

s = "aa,Bbcc,Ddf"
# 返回全部字符大写
print(s.upper())  # AA,BBCC,DDF
# 返回全部字符小写
print(s.lower())  # aa,bbcc,ddf
# 返回一个列表,由字符串被分割部分组成
# str -- 分隔符,默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等
# num -- 分割次数。默认为 -1, 即分隔所有
print(s.split(','))  # ['aa','Bbcc','Ddf']
# 以哪个为分隔符,哪个分割符就不会出现在结果
print(s.split('b', 1))  # ['aa,B','cc,Ddf']
# 返回子串sub在str中出现的次数,区分大小写并且区分顺序
print(s.count("a"))  # 2
print(s.count("aa"))  # 0
# 返回字符串str副本,所有old字符串被替换成new
# 但对原来的字串符没影响
# 第三个参数默认-1:替换所有old出现的次数 0:不替换 1:替换出现的第一次
flag = s.replace("a", "PP")
print(s)  # aa,Bbcc,Ddf
print(flag)  # PPPP,Bbcc,Ddf
# 通过指定一个宽度值width,将str在该宽度内居中
# 参数二为填充的内容默认是空格填充可选,只能是单个字符
# 如果width值小于str的值则原样返回str
# 当str为奇数,指定宽度为偶数时,优先向右边补填充内容
# 当str为偶数,指定宽度为奇数时,优先向左边补填充内容
print(s.center(21, "@"))  # @@@@@aa,Bbcc,Ddf@@@@@
# 从str中去掉在其左侧和右侧chars中列出的值
# 只能删除开头或是结尾的字符,不能删除中间部分的字符
# 没参数默认为空格或换⾏符
print(s.strip("af"))  # ,Bbcc,Dd
# 在iter变量除最后元素外每个元素后增加一个str
s2 = '-'
s3 = ['2022', '05', '27']
print(s2.join(s3))  # 2022-05-27
print(s2.join('我还是我以前的我'))  # 我-还-是-我-以-前-的-我
  • str.replace() 函数第三参数取值范围如下

  • 字符串类型的格式化

# 通过关键字(关键字= 不需要空格隔开)
print("{name}在{option}".format(name="小明", option="吃饭"))  # 小明在吃饭
# 通过位置
print("{}在{}".format("小芳", "跳舞"))  # 小芳在跳舞
print("{0}在{1}".format("小芳", "跳舞"))  # 小芳在跳舞
print("{1}在{0}".format("小芳", "跳舞"))  # 跳舞在小芳
# 居中
# 20:字段长度(最左到最右之间的长度)
print("{:=^20}".format("123"))  # ========123=========
# 左对齐
print("{:<20}".format("123"))
# 右对齐
print("{:>20}".format("123"))
# 精度控制(保留2位小数并且四舍五入)
print("{:.2f}".format(3.14859))  # 3.15
# 进制转换 b o d x 分别表示二、八、十、十六进制
print("{:b}".format(29))  # 11101
print("{:o}".format(29))  # 35
print("{:d}".format(29))  # 29
print("{:x}".format(29))  # 1d

附录1 字符串常用操作

  • 判断类型

  • 查找和替换

  • 大小写转换

  • 文本对齐

  • 去除空白字符

  • 拆分和连接

数据类型之序列类型

定义

  • 序列是具有先后关系的一组元素
  • 序列是一维元素向量,元素类型可以不同
  • 元素间由序号引导,通过下标访问序列的特定元素
  • Python语言中很多数据类型都是序列类型,其中比较重要的是字符串类型,元组类型和列表类型

通用操作符与函数

arr = ["python", "C语言", "1223"]
brr = ["MySQL", "挂科"]
# 如果x是序列arr的元素返回True,否则返回false
print("C语言" in arr)  # True
print("C语" in arr)  # False
# 如果x是序列arr的元素,返回False,否则返回True
print("python" not in arr)  # False
print("sb" not in arr)  # True
# 连接两个序列arr和brr
print(arr+brr)  # ['python', 'C语言', '1223', 'MySQL', '挂科']
# 将序列arr复制n次
print(arr*2)  # ['python', 'C语言', '1223', 'python', 'C语言', '1223']
# 索引,返回arr中第i个元素
print(arr[0])  # python
# 切片,返回序列arr第i到第j个元素(不包括第j个元素)
# 跟字符串操作一样
print(arr[1:3])  # ['C语言', '1223']
# 切片,返回序列arr第i到第j个元素(不包括第j个元素),以k为步长
print(arr[0:3:2])  # ['python', '1223']
print(arr[::-1])  # ['1223', 'C语言', 'python']

arr = ["python", "C语言", "A"]
brr = ["12", "12", "12", "23"]
# 返回序列arr的长度,即元素个数
print(len(arr))  # 3
# 返回序列arrASCII码最小的元素,arr中元素需要能比较
print(min(arr))  # A
# 返回序列arrASCII最大元素
print(max(arr))  # python
# 返回序列arr从i到j第一次出现元素x的位置
# 如果i到j都没有这个元素则报错
print(arr.index("python"))  # 0
print(arr.index("A", 0, 3))  # 2
# 返回序列arr中出现x的总次数
print(brr.count("12"))  # 3

数据类型之列表类型

定义

  • List(列表) 是 Python 中使用 最频繁 的数据类型,在其他语言中通常叫做 数组
  • 专门用于存储 一串 信息
  • 列表用 [] 定义,数据 之间使用 , 分隔
  • 列表中各元素类型可以不同无长度限制
  • 列表的索引从0开始

注意:从列表中取值时,如果 超出索引范围,程序会报错

# 创建列表
list1 = [1, 2, 3, 4, 5]
list2 = ["C语言", "C++"]

# 在指定位置插入数据
list1.insert(0, 0)
print(list1)  # [0, 1, 2, 3, 4, 5]
# 在末尾追加数据
list1.append(6)
print(list1)  # [0, 1, 2, 3, 4, 5, 6]
# 将list2的数据追加到list1
list1.extend(list2)
print(list1)  # [0, 1, 2, 3, 4, 5, 6, 'C语言', 'C++']
# 修改指定索引数据
list1[0] = -1
print(list1)  # [-1, 1, 2, 3, 4, 5, 6, 'C语言', 'C++']
# 删除指定索引的数据
del list1[8]
print(list1)  # [-1, 1, 2, 3, 4, 5, 6, 'C语言']
# 删除第一个出现的指定数据
list1.remove(1)
print(list1)  # [-1, 2, 3, 4, 5, 6, 'C语言']
# 删除末尾数据
list1.pop()
print(list1)  # [-1, 2, 3, 4, 5, 6]
# 删除指定索引数据
list1.pop(5)
print(list1)  # [-1, 2, 3, 4, 5]
# 列表长度
print(len(list1))  # 5
# 数据在列表中出现的次数
print(list1.count(2))  # 1
# 升序排序,没参数默认升序
list1.sort()
print(list1)  # [-1, 2, 3, 4, 5]
# 降序
list1.sort(reverse=True)
print(list1)  # [5, 4, 3, 2, -1]
# 逆序
list1.reverse()
print(list1)  # [-1, 2, 3, 4, 5]
# 复制列表,生成新的列表
list3 = list1.copy()
print(list3)  # [-1, 2, 3, 4, 5]
# 清空列表
list1.clear()
print(list1)  # []
  • 迭代遍历
list1 = [1, 2, 3, 4, 5]
# 遍历
for name in list1:
    print(name)

数据类型之元组类型

定义

  • 元组是序列类型的一种扩展
  • 一旦创建就不能被修改
  • 使用小括号 ()tuple() 创建,元素间用逗号分隔(字符串元素用单引号或者双引号括起来,数值则不需要)
  • 可以使用或不使用小括号
  • 索引也是从0开始
  • 元组是不可变类型,它的指针数组无需变动,故内存分配乃一次性完成。另外,系统会缓存复用一定长度的元组内存。创建时,按长度提取复用,无需额外内存分配(包括指针数组)。从这点上看,元组的性能要好于列表
  • 元组可当做列表只读版本使用
  • 元组相同序号总是返回同一对象故可为序号取个别名

注意:元组中 只包含一个元素 时,需要 在元素后面添加逗号

tuple1 = (12,)

常用操作

元组继承了序列类型的全部通用操作,但是由于创建后不能修改,因此没有特殊操作

# 创建空元组
tuple1 = ()
# 可以不使用小括号
tuple2 = 12, 13, 14, 15
tuple3 = ("abc", "def")
print(tuple2)  # (12, 13, 14, 15)
# 访问元组
print(tuple2[2])  # 14
# 倒序
print(tuple2[::-1])  # (15, 14, 13, 12)
# 元组中的元素值是不允许修改的,但我们可以对元组进行连接组合
tuple4 = tuple2 + tuple3
print(tuple4)  # (12, 13, 14, 15, 'abc', 'def')
print(type(tuple4))  # <class 'tuple'>
# 元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
del tuple4
print("删除后:\n")
print(tuple4)  # 报错:未定义'tuple4'
# 计算元素个数
print(len(tuple2))  # 4
# 复制
print(tuple2*2)  # (12, 13, 14, 15, 12, 13, 14, 15)
# 元素是否存在
print(12 in tuple2)  # True
# 遍历
for my_tuple in tuple2:
    print(my_tuple)  # 12 13 14 15

应用场景

  • 尽管可以使用 for in 遍历 元组
  • 在开发中应用场景是:
    函数的 参数 和 返回值,一个函数可以接收 任意多个参数,或者 一次返回多个数据
    格式字符串,格式化字符串后面的 () 本质上就是一个元组
    让列表不可以被修改,以保护数据安全
info = ("小明", 18)
print("%s的年龄是%d" % info)  # 小明的年龄是18

元组和列表之间的转换

  • 使用 list 函数可以把元组转换成列表
list(元组)
  • 使用 tuple 函数可以把列表转换成元组
tuple(列表)

数据类型之字典类型

定义

  • dictionary(字典) 是 除列表以外 Python 之中 最灵活 的数据类型(类似C语言的结构体)
  • 字典同样可以用来 存储多个数据(通常用于存储 描述一个 物体 的相关信息)
  • 和列表的区别
    列表 是 有序 的对象集合
    字典 是 无序 的对象集合
  • 字典用 {} 定义
    字典使用 键值对 存储数据,键值对之间使用 , 分隔
  • key索引value数据
  • 键 和 值 之间使用 : 分隔 键必须是唯一的
    可以取任何数据类型,但 只能使用 字符串、数字或 元组(列表不行)
  • 字典是包含0个或多个键值对的集合,没有长度限制,可以根据键索引值的内容

# 定义一个字典
# 使用字典来存储用户提供的数据或在编写能自动生成大量键-值对的代码时,都通常需要先定义一个空字典
dict1 = {"name": "小红", "年龄": 19, "电话": 123456}
print(type(dict1))  # <class 'dict'>
# 返回所有key(键)
# 返回所有value(值)
print(dict1.keys())  # dict_keys(['name', '年龄', '电话'])
print(dict1.values())  # dict_values(['小红', 19, 123456])
# 返回(key, value)元组列表
print(dict1.items())  # dict_items([('name', '小红'), ('年龄', 19), ('电话', 123456)])
# 取值,key不存在会报错(注意要加引号)
print(dict1["name"])  # 小红
# 取值,key不存在不会报错,会返回default值:None
print(dict1.get("na"))  # None
# 如果key存在,修改数据,不存在则新建键值对
dict1["生日"] = 20020829
print(dict1)  # {'name': '小红', '年龄': 19, '电话': 123456, '生日': 20020829}
dict1["name"] = "李四"
print(dict1["name"])  # 李四
# 如果key存在,不会修改数据,不存在则新建
dict1.setdefault("name", "小虎")
print(dict1)  # {'name': '李四', '年龄': 19, '电话': 123456, '生日': 20020829}
dict1.setdefault("height", "1.75")
print(dict1)  # {'name': '李四', '年龄': 19, '电话': 123456, '生日': 20020829, 'height': '1.75'}
# 将dict2的数据合并到dict1中
dict2 = {"学号": 2021}
dict3 = dict1.update(dict2)  # 不能赋值,这是错误的
print(dict1)  # {'name': '李四', '年龄': 19, '电话': 123456, '生日': 20020829, 'height': '1.75', '学号': 2021}
# 删除指定键值对,key不存在会报错(两种方法)
dict1.pop('电话')
print(dict1)  # {'name': '李四', '年龄': 19, '生日': 20020829, 'height': '1.75', '学号': 2021}
del dict1["生日"]
print(dict1)  # {'name': '李四', '年龄': 19, 'height': '1.75', '学号': 2021}
# 随机删除一个键值对(一般删除末尾对)
dict1.popitem()
print(dict1)  # {'name': '李四', '年龄': 19, 'height': '1.75'}
# 返回字典的键值对数
print(len(dict1))  # 3
# 判断键是否在字典dict1中,如果在返回True,否则False
print("name" in dict1)  # True
# 清空字典
dict1.clear()
print(dict1)  # {}
  • 遍历字典(可遍历字典的所有键值对、键或值
# 遍历所有键值对
dict1 = {"name": "小红", "年龄": 19, "电话": 123456}
for name in dict1:
    print("%s: %s" % (name, dict1[name]))

# 需要字典的值都是字符串类型,否则报错
dict1 = {"name": "小红", "年龄": "19", "电话": "123456"}
for key, value in dict1.items():
    print("\nkey:" + key)
    print("value:" + value)

# 输出所有的键
dict1 = {"name": "小红", "年龄": "19", "电话": "123456"}
for key in dict1.keys():
    print(key)
# 或者
dict1 = {"name": "小红", "年龄": "19", "电话": "123456"}
for name in dict1:
    print(name)

# 输出所有的值
dict1 = {"name": "小红", "年龄": "19", "电话": "123456"}
for value in dict1.values():
    print(value)

# sorted默认时是对键进行排序
dict1 = {"A": "2", "C": "5", "B": "1"}
# 键排序
for name in sorted(dict1):
    print(name)
# 值排序(降序)
for name in sorted(dict1.values(), reverse=True):
    print(name)

  • 剔除重复项,可以使用集合(set)集合类似于列表,但对每个元素都必须是独一无二的。通过对包含重复元素的列表调用 set(),可以让Python找出列表中独一无二的元素,并使用这些元素来创建集合
dict1 = {"A": "2", "C": "2", "B": "1", "F": "2"}
# 值去重
for name in set(dict1.values()):
    print(name)

数据类型之集合类型

定义

  • 集合是多个元素的无序组合
  • 集合元素之间无序每个元素唯一,不存在相同元素应用于数据去重,即集合类型所有元素无重复
  • 集合元素不可更改,不能是可变数据类型
  • 集合用大括号 {} 表示,元素间用 , 分隔
  • 建立集合类型用 {}set()
  • 建立空集合类型,必须使用 set()

gather = {123, "123", "A", "BB"}
gather2 = {123, "金", "木"}
# 返回类型
print(type(gather))  # <class 'set'>
# S|T,返回所有元素的新集合
gather3 = gather | gather2
print(gather3)  # {'BB', '金', '木', 'A', 123, '123'}
# S&T,返回两个集合相同的元素
gather3 = gather & gather2
print(gather3)  # {123}
# S-T,返回包括在集合S但不在T中的元素
gather3 = gather - gather2
print(gather3)  # {'A', '123', 'BB'}
# S^T,返回包括集合S和T中的非相同的元素
gather3 = gather ^ gather2
print(gather3)  # {'A', '123', 'BB', '金', '木'}
# S<=T或S<T,返回True/False,判断两个集合的子集关系
# 如果集合S的元素都属于集合T的元素,那说明T包含S,T<=S(两个集合元素一样需要<=/==)
gather4 = {123}
gather3 = gather <= gather2
print(gather3)  # False
gather3 = gather4 <= gather  # 等同于 gather >= gather4
print(gather3)  # True
# S|=T,并,更新集合S,跟上面那个一样(这个不会生成新集合)
gather |= gather2
print(gather)  # {'木', 'BB', 'A', 123, '金', '123'}

gather = {123, "123", "A", "BB"}
# 如果x不在集合S中,将x增加到S
gather.add(666)
print(gather)  # {'A', '123', 666, 123, 'BB'}
# discard:移除S中元素x,如果x不在集合S中,不报错
# remove:移除S中元素x,如果x不在集合S中,产生KeyError异常
gather.discard(123)
print(gather)  # {'A', 'BB', '123', 666}
# gather.remove(0)
# print(gather)  # KeyError: 0
# 随机删除S的一个元素,更新S,若S为空,则产生KeyError异常
gather.pop()
print(gather)  # {'BB', 666, '123'}
# 返回集合S的一个副本
gather2 = gather.copy()
print(gather2)  # {'BB', 666, '123'}
print(len(gather))  # 3
# 判断S中元素x,x在集合S中,返回True,否则返回False
print(123 in gather)  # False
# 判断S中元素x,x不在集合S中,返回True,否则返回False
print(123 not in gather)  # True
# 将其他类型变量x转变为集合类型(去重)
tuple1 = (1, 2, 1, 3, 6)
print(set(tuple1))  # {1, 2, 3, 6}

控制语句

分支结构与选择结构

  • Python 程序语言指定任何非0和非空(null)值true0 或者 nullfalse
  • Python 是⼀种靠 缩进 来判断逻辑的语言!所以缩进尤为重要,如果缺失缩进程序运行会报错!
  • Python 采用 代码缩进冒号( : )区分代码块之间的层次
  • 对于类定义、函数定义、流程控制语句、异常处理语句等行尾的冒号下一行的缩进表示下一个代码块的开始而缩进的结束表示此代码块的结束
  • 通常情况下都是采用 4 个空格长度作为一个缩进量(默认情况下,一个 Tab 键就表示 4 个空格)
  • Python 要求属于同一作用域中的各行代码它们的缩进量必须一致,但具体缩进量为多少,并不做硬性规定
# 注意缩进
if 2 > 1:
    print("true")
    print("True")
# 运行结果:true True

a = 2
if a == 0:  # 注意不能直接2==0
    print("你好")
else:
    print("不好")
# 运行结果:不好

# 紧凑形式
# <表达式1> if <条件> else <表达式2>
# 条件成立则输出表达式1,不成立则输出表达式2
guess = eval(input("请输入数字:"))
print("你猜{}了".format("对" if guess == 99 else "错"))  # 99  你猜对了
a = 1
b = 2
# and:与 or:或 not:非
if (a and b) > 0:
    print("大于0")
else:
    print("小于0")
# 输出结果:大于0
a = 1
b = 2
# 从上到下运行
if (a and b) > 0:
    print("第一")
elif a == 1:
    print("第二")
elif b == 2:
    print("第三")
else:
    print("第四")
# 输出结果:第一
# 嵌套
a = 1
b = 2
if (a and b) > 0:
    if a == 1:
        print("666")
    else:
        print("999")
else:
    print("123")
# 输出结果:666

注意elifelse 都必须和 if 联合使用,不能单独使用,虽然该语句的备选动作较多,但是有且只有一组动作被执行

  • pass语句

Python 提供了一个关键字 pass,类似于空语句,可以用在类和函数的定义中或者选择结构中。当暂时没有确定如何实现功能,或者为以后的软件升级预留空间,都可以使用该关键字来“占位”

a = 1
b = 2
if (a and b) > 0:
    pass
else:
    pass
# 输出结果:无
  • 随机数的处理
# 导入模块
import random
num1 = random.randint(1, 10)  # 生成随机数n:1<=n<=10
num2 = random.randint(3, 3)  # 结果永远是3
num3 = random.randint(10, 3)  # 错误,下限必须小于上限

循环结构

  • while 循环
a = 1
while a < 20:
    print(a)
    a += 5
# 输出结果:1 6 11 16
# while … else 在循环条件为 false 时执行 else 语句块
# 循环正常执行完才会执行else,break导致退出的不会执行
a = 1
while a < 4:
    print(a)
    a += 1
else:
    print(666)
# 输出结果:1 2 3 666

# 如果你的 while 循环体中只有一条语句,你可以将该语句与while写在同一行中
while 1: print(6)
  • for循环
# 从遍历结构中逐一提取元素,放在循环变量中
# 每次循环,所获得元素放入循环变量,并执行一次语句块
for<循环变量> in <遍历结构>:
    <语句块>
  • range(start, stop[, step]) 函数可创建一个对象(Python3),参数1:计数开始处,默认 0参数2:结束处,不包括参数2本身;参数3:步长,默认 1
str1 = "123456"
for i in range(len(str1)):
    print(str1[i])  # 1 2 3 4 5 6
# 0-3,步长为2
# for ... else 跟 while ... else 一样
num = 0
for i in range(0, 4, 2):
    print(num+i)  
else:
    print("正常结束")
# 输出结果:# 0 2 正常结束

# 列表循环遍历
for i in ["1", "2", "3"]:
    print(i)  # 1 2 3
    
# 文件遍历循环
# fi是一个文件标识符,遍历每行产生循环
for line in fi
	<语句块>

循环控制保留字

  • break 语句

break用来跳出最内层for或while循环,脱离该循环后程序从循环代码后继续执行

注意:若有双重循环时,仅退出当前层次循环

s1 = "abcde"
for name in s1:
    if name == "c":  # 遇到c直接退出循环
        break
    print(name)  # a b 
  • continue语句

用来结束当前当次循环,即跳出循环体中下面尚未执行的语句,但不跳出当前循环

s1 = "abcde"
for name in s1:
    if name == "c":  # 跳过c
        continue
    print(name)  # a b d e

注意breakcontinue 只针对 当前所在循环 有效

try-except语句

  • 这个 try-except 语句是 异常捕获 语句
  • eval() 函数用来执行一个字符串的表达式,并返回表达式的值
  • 还可以把字符串转化为list、tuple、dict
s1 = "[1, 2, 3, 4, 5]"
print(type(s1))  # <class 'str'>
s2 = eval(s1)
print(type(s2))  # <class 'list'>
# 主要看" "里面是什么类型就转换成什么类型
# []->列表   {}->字典  ()->元组

# 还可以返回表达式的值
a = 4
print(eval("a+1"))  # 5

x=10
b=20
c=30
g={'a':6,'b':8}  # a=6 b=8
t={'b':100,'c':10}  # b=100 c=10
eval('a+b+c',g,t)  # 优先使用局部变量所以上面的x,b,c不会用到,然后按顺序执行,把g,t位置调换结果也会不同 
 
# 返回值为116
  • 异常处理
# 语法
try:  # # 写一个 try 把可能出错的代码放进去
    <语句块1>
except <异常类型>:  # 写一个except
    <语句块2>		# 书写捕获异常的处理方案
try:
    print("-----test--1----")
    open("123.txt", "r")
    print("-----test--2--- ")
except IOError as e:
    print("捕获异常", e)
# 捕获到异常,没有这个123.txt文件
# 运行结果:
# -----test--1----
# 捕获异常 [Errno 2] No such file or directory: '123.txt'

此程序捕获到错误,因为用 except 捕获到了 IOError 异常,并添加了处理的方法
except 添加错误基类 IOError try语句出错则执行 exceptprint语句,那么就会输出错误信息
从执行结果可以看到:捕获到的错误保存到变量,控制台可以打印出具体的错误信息。

try:
    print(num)
except IOError:
    print("捕获异常")

运行结果:

注意except 捕获的错误类型是 IOError ,而此时程序产生的异常为 NameError ,所以 except 没有生效

  • 当捕获多个异常时,可以把要捕获的异常的名字,放到 except 后,并使用元组的方式仅进行存储
try:
    print('-----test--1---')
    open('123.tx','r') # 如果123.txt文件不存在,那么会产生 IOError 异常
    print('-----test--2---')
    print(num)# 如果num变量没有定义,那么会产生 NameError 异常

except (IOError,NameError) as e:
    # 如果想通过一次except捕获到多个异常可以用一个元组的方式
    print('捕获到异常信息:',e)

  • 此处的 else 语句与 for 循环和 while 循环中 else 一样,当 try 中的语句块1正常执行结束且没有发生异常时,else 中的语句块3执行。

    2、finall 语句块则不一样,无论 try 中的语句块1是否发生异常,语句块4都会执行,因此将程序执行语句块1的一些收尾工作放在这里,例如:关闭、打开文件等。

try:
    <语句块1>
except<异常类型1>:
    <语句块2>
else:
    <语句块3>
finally:
    <语句块4>
  • 当你不知道错误基类时,就统一用 Exception (可以捕获所有错误)

函数的定义与使用

函数的定义

  • def 是英文 define 的缩写
  • 函数命名应该符合 标识符的命名规则

  • 函数调用:通过 函数名() 即可对函数调用,定义完成后,若不自动调用函数,函数不会自动执行

  • 在函数名后面的小括号内部填写 参数,参数之间用 , 分隔

  • 形参和实参

    形参:定义函数时,小括号中的参数,用于接收参数,在函数内部 作为变量使用

    实参:调用 函数时,小括号中的参数,将数据传递到 函数内部

  • return 表示返回,后续的代码都不会被执行

lambda 函数

lambda 表达式可以用来声明匿名函数,又称 lambda函数 ,匿名函数不是真的没有名字,而是将函数名作为函数结果返回

<函数名> = lambda <参数列表>: <表达式> 

# 等价于下面形式
def <函数名>(<参数列表>):
    return <表达式>
# 将lambda 函数赋给一个变量
num = lambda x, y: x+y
print(type(num))  # <class 'function'>
print(num(1, 2))  # 3
# 警告:PEP 8:E731 do not assign a lambda expression,use a def
# PEP8规范并不推荐将lambda表达式赋值给一个变量,再通过变量调用函数这种方式。
# 这种方式不能体现lambda表达式的特色,基本只是复制def的功能,
# 同时这个变量名其实也不是lambda表达式真正的函数名,还显得比def方式更容易混淆
  • 写完函数和类之后要空出两个空行(方便区分)
  • 如果定义的函数没有返回值,Python 解释器就会(强行地)默认给我们注入一段返回逻辑!(None)
  • return语句同时可以将0个、1个或多个函数运算完的结果返回给函数被调用处的变量,返回多个值时以元组类型保存
  • 如果一个函数返回的是元组,括号可以省略
# 函数可以没参数,但是括号必须保留
def fact():
    print("这是个函数")


def fact2(x, y):
    return x+y


print(fact())  # 这是个函数  None
print(fact2(2, 4))  # 6

参数

  • 定义函数时,给某个参数指定一个默认值,叫做 缺省
  • 调用函数时,如果没有传入参数则默认使用 默认参数

注意:必须保证带有默认值的缺省参数在参数列表末尾,在调用函数时,如果有多个缺省参数,需要指定参数名,这样解释器才能够知道参数的对应关系!

def fact2(x=1, y=2):
    return x+y


# 指定参数名,不指定默认是替换左边
print(fact2(y=9))  # 10

使用模块中的函数

  • 模块 就好比是 工具包,要想使用这个工具包中的工具,就需要 导入 import 这个模块
  • 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 模块
  • 在模块中定义的 全局变量 、 函数 都是模块能够提供给外界直接使用的工具
  • 可以 在一个 Python 文件 中 定义 变量 或者 函数,然后在 另外一个文件中 使用 import 导入这个模块
  • 导入之后,就可以使用 模块名.变量 / 模块名.函数 的方式,使用这个模块中定义的变量或者函数
  • 模块名也是遵循标志符起名规则

不可变和可变参数

  • Python 中,string(字符串), tuples(元组), 和number(数值)是不可更改的对象(形参),而 list(列表), dict(字典)等则是可以修改的对象(实参)
  • Python 中一切都是 对象 ,严格意义我们不能说 值传递 还是 引用传递 ,我们应该说 传不可变对象传可变对象
  • 形参的数值对于外部的实参的数值(number类型,不可变)来说是没有任何关系的,他们虽然是同一个名字但是其指向对象是不一样的
x = 1
y = 2


def fact2(x,  y):
    x = 3
    y = 6
    return x+y


fact2(x, y)
print(x, y)  # 1 2
# 修改实参
def change(list1):
    list1.append(6)
    print(list1)  # [1, 2, 3, 6]


my_list = [1, 2, 3]
change(my_list)
print(my_list)  # [1, 2, 3, 6]

多值参数

  • 有时可能需要 一个函数 能够处理的参数 个数 是不确定的,这个时候,就可以使用 多值参数

  • python中有两种多值参数:

    参数名前增加 一个 * 可以接收 元组 如:*args

    参数名前增加 两个 * 可以接收 字典 如:**kwargs

def power(*tuple1):
    result = 0
    for n in tuple1:
        result += n
    return result


my_tuple = (1, 3, 5, 7)
print(power(*my_tuple))  # 16

def power(name, age, **dict1):
    print("name:", name, "age:", age, "other:", dict1 )


my_dict = {"A": 1, "B": 2, "C": 3}
power("Jack", 18, **my_dict)
# 运行结果:name: Jack age: 18 other: {'A': 1, 'B': 2, 'C': 3}
# 注意:要两个*才代表字典,一个*是元组
  • 可变参数既可以直接传入:func(1, 2, 3),又可以先组装 listtuple,再通过 *args 传入:func(*(1, 2, 3))
  • 关键字参数既可以直接传入:func(a=1, b=2),又可以先组装dict ,再通过 **kw 传入:func(**{‘a’: 1, ‘b’: 2})
def power(*dict1):
    print("other:", dict1)


power(*(1, 2, 3, 4))
# 运行结果:other: (1, 2, 3, 4)

递归的关键特征

  • 存在一个或多个基例,基例不需要再次递归,它是确定的表达式(是一个能直接算出值的表达式)。
  • 所有递归链要以一个或多个基例结尾
  • Python 的递归深度是有限制的,默认为1000。当递归深度超过1000时,就会报错

字符串倒序:

def reverse(s):
    if s == "":
        return s
    else:
        return reverse(s[1:]) + s[0]


arr = input("请输入一个字符串:")
print(reverse(arr))
# 或者
print(arr[::-1])
# 斐波那契数列
def f(n):
    if n == 1 or n == 2 :
        return 1
    else:
        return f(n-1) + f(n-2)
n = eval(input("请输入一个整数:"))
x = f(n)
print(x)

一维数据与二维数据

一维数据

  • 一维数据的表示:列表类型可以表达一维有序数据,集合类型可以表达一维无序数据

  • for 循环可以遍历数据,进而对每个数据进行处理

  • 一维数据的存储

    存储方式一:空格分隔

    使用 一个或多个空格 分隔进行存储,不换行

    存储方式二:逗号分隔

    使用 英文半角逗号 分隔数据进行存储,不换行

    存储方式三:其他方式

    使用 其他符号或符号组合 分隔,建议采用特殊符号

  • 一维数据的写入处理

    采用空格分隔方式将数据写入文件:

Is = ["李白", "张飞", "周瑜", "孙尚香", "孙悟空"]
tf = open("E:\\测试.txt", "w")
tf.write(" ".join(Is))
tf.close()

采用特殊符号分隔方式将数据写入文件:

Is = ["李白", "张飞", "周瑜", "孙尚香", "孙悟空"]
tf = open("E:\\测试.txt", "w")
tf.write("@".join(Is))
tf.close()

  • 一维数据的读入处理

    从空格分隔的文件中读入数据:

tf = open("E:\\测试.txt", "r", encoding="gb2312")
txt = tf.read()
Is = txt.split()  # 如果屏蔽此句则原样输出
print(Is)
tf.close()

# 输出为列表形式
# 运行结果:['李白', '张飞', '周瑜', '孙尚香', '孙悟空']

注意:如果报错:UnicodeDecodeError: ‘utf-8’ codec can’t decode byte 0xc0 in position 0: invalid start byte ; 则需要把 utf-8 改成 gb2312

从特殊符号分隔的文件中读入数据:

tf = open("E:\\测试.txt", "r", encoding='gb2312')
txt = tf.read()
Is = txt.split("@")
print(Is)
tf.close()

# 运行结果:['李白', '张飞', '周瑜', '孙尚香', '孙悟空']

二维数据

  • 列表类型可以表达二维数据(使用二维列表)
  • 使用 for 循环遍历每个元素
  • CSV 格式与二维数据存储

注意:每行一个一维数据,采用 , 分隔,无空行

注意

① 纯文本格式,通过单一编码表示字符。
② 以为单位,开头不留空行,行之间没有空行
每行表示一个一维数据,多行表示二维数据
④ 以逗号(英文,半角)分割每列数据,列数据为空也要保留逗号
⑤ 对于表格数据,可以包含或不包含列名,包含时列名放置在文件第一行。

二维数据的写入处理(将数据写入CSV格式的文件)

# 方法1
import csv  # 导入模块

Is = [["姓名", "数学", "英语"], ["小虎", "56", "87"], ["小兰", "76", "89"]]
# 表示写入csv文件,如果不加上参数 newline='' 表示以空格作为换行符不加会出现一行隔一行
tf = open("E:\\测试.csv", "w", newline="")
writer = csv.writer(tf)
for name in Is:
    writer.writerow(name)  # 将多列数据写入一行
tf.close()
# 方法2
Is = [["姓名", "数学", "英语"], ["小虎", "56", "87"], ["小兰", "76", "89"]]
tf = open("E:\\测试.csv", "w")
for name in Is:
    tf.write(",".join(name) + "\n")  # 列表item以“,”为分隔符转换成字符串写入
tf.close()

二维数据的读入处理(从CSV格式的文件中读入数据)

# 方法1
tf = open("E:\\测试.csv", "r")
Is = []  # 建一个空白列表
for name in tf:
    name = name.replace("\n", " ")  # 把换行换成空格
    Is.append(name.split(","))
print(Is)  # 此时Is为二维数据,所以应注意输出格式
for name in Is:
    name = ",".join(name)  # 列表以“,”为分隔符转换成字符串传输出
    print(name)
tf.close()
# 方法2
import csv

tf = open("E:\\测试.csv", "r")
reader = csv.reader(tf)
# 因为csv.reader()返回是一个迭代类型,需要通过循环或迭代器访问
# 所以你需要自己开一个列表,循环这个reader将内容添加至新的列表中即可
print(reader)  # <_csv.reader object at 0x0000023F6D36F340>
show = []
for i in reader:
    show.append(i)
print(show)  # # 此时Is为二维数据,所以应注意输出格式
for i in show:
    print(i)

文件操作(待更新)