前言
众所周知，python是所有编程语言中最不容易掉头发的语言，而其庞大的功能包，则运用在很多领域，在学校里学的感觉马马虎虎，所以又按照自己的思路学了一遍，这里的视频参照来源B站黑马程序员的python基础课程，所有的笔记也从它免费的笔记中有所参照
01
介绍python
1.Python 源程序就是一个特殊格式的文本文件，可以使用任意文本编辑软件做 Python 的开发
2.Python 程序的 文件扩展名 通常都是 .py
单词列表
* error 错误
* name 名字
* defined 已经定义
* syntax 语法
* invalid 无效
* Indentation 索引
* unexpected 意外的，不期望的
* character 字符
* line 行
* encoding 编码
* declared 声明
* details 细节，详细信息
* ASCII 一种字符编码
python解释器
# 使用 python 2.x 解释器
python xxx.py
# 使用 python 3.x 解释器
python3 xxx.py
* CPython —— 官方版本的 C 语言实现
* Jython —— 可以运行在 Java 平台
* IronPython —— 可以运行在 .NET 和 Mono 平台
* PyPy —— Python 实现的，支持 JIT 即时编译
解释器与编译器的区别
编译型语言：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依赖编译器，跨平台性差些。如 C、C++
解释型语言：解释型语言编写的程序不进行预先编译，以文本方式存储程序代码，会将代码一句一句直接运行。在发布程序时，看起来省了道编译工序，但是在运行程序的时候，必须先解释再运行
注释
# 单行注释
""" 多行注释 """
代码规范
参考PEP-8
原文：https://www.python.org/dev/peps/pep-0008/
中文：http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/
运算符
1.算术运算符
+ 加
- 减
* 乘（也可以用来重复字符串）
/ 除
// 取整
% 取余
** 幂
2.比较（关系）运算符
== #相等
!= #不相等
> #大于
< #小于
>= #大于等于
<= #小于等于
3.逻辑运算符
and #与，一假即假
or #或，一真即真
not #否定
4.赋值运算符
= #赋值
+= #加法赋值
-= #减法赋值
*= #乘法赋值
/= #除法赋值
//= #取整除赋值
%= #取模(余数)赋值
**= #幂赋值运算符
优先级
** # 幂 (最高优先级)
* / % // # 乘、除、取余数、取整除
+ - # 加法、减法
<= < > >= # 比较运算符
== != # 等于运算符
= %= /= //= -= += *= **= # 赋值运算符
not or and # 逻辑运算符
#同级运算符是从左至右计算，可以使用 () 调整计算的优先级
变量
在 Python 中，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建 # 变量名 = 值
类型：
* 数字型
* 整型 (int)
* 浮点型（float）
* 布尔型（bool）
* 真 True 非 0 数 —— 非零即真
* 假 False 0
* 复数型 (complex)
* 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
* 非数字型
* 字符串
* 列表
* 元组
* 字典
不同变量之间的计算
1.数字型变量之间可以直接计算
2.字符串变量之间使用 + 拼接字符串
3.字符串变量可以和整数使用 * 重复拼接相同的字符串
4.数字型变量和字符串之间不能进行其他计算
变量相关的函数
print(x) # 将x输出到控制台
type(x) # 查看x的变量类型
字符串变量 = input("提示信息：") #键盘输入（用户输入的任何内容Python都认为是一个字符串）
int(x) # 将 x 转换为一个整数
float(x) # 将 x 转换到一个浮点数
变量的格式化输出
%s #字符串
%d #有符号十进制整数，%6d 表示输出的整数显示 6 位数，不足的地方使用 0 补全
%f #浮点数，%.2f 表示小数点后只显示两位
%% #输出 %
eg：print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))
02
标识符
程序员定义的变量名、函数名
1.可以由字母、下划线和数字组成
2.不能以数字开头
3.不能与关键字重名
关键字
在 python 内部已经使用的标识符、具有特殊的功能和含义且不允许定义和关键字相同的名字的标示符
#查看关键字
import keyword
print(keyword.kwlist)
命名
* 小驼峰式命名法
* 第一个单词以小写字母开始，后续单词的首字母大写
* 例如：firstName、lastName
* 大驼峰式命名法
* 每一个单词的首字母都采用大写字母
* 例如：FirstName、LastName、CamelCase
if语句
1.if 要判断的条件:
条件成立时，要做的事情
2.if 要判断的条件:
条件成立时，要做的事情
else:
条件不成立时，要做的事情
3.if 条件1:
条件1满足执行的代码
elif 条件2:
条件2满足时，执行的代码
else:
以上条件都不满足时，执行的代码
# if语句可嵌套
while循环
初始条件设置——通常是重复执行的计数器
while 条件(判断 计数器 是否达到 目标次数):
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
......
处理条件(计数器 + 1)
# 忘记在循环内部修改循环的判断条件，导致循环持续执行，程序无法终止
break和continue
* break 某一条件满足时，退出循环，不再执行后续重复的代码，相当于跳出循环
* continue 某一条件满足时，不执行后续重复的代码，相当于直接结束这一次的循环
# while语句也可嵌套
转义字符
\\ #反斜杠符号
\' #单引号
\" #双引号
\n #换行
\t #横向制表符
\r #回车（光标移到行首，如果有输入会覆盖之前的代码）
03-函数
定义：函数，就是把具有独立功能的代码块 组织为一个小模块，在需要的时候调用
使用步骤：
1. 定义函数 —— 封装 独立的功能
2. 调用函数 —— 享受 封装 的成果
作用：提高编写的效率以及代码的 重用
def 函数名():
函数封装的代码
# 函数名称应该能够表达函数封装代码的功能以方便后续的调用，且命名应该符合标识符的命名规则
参数的使用
def sum_2_num(num1, num2):
result = num1 + num2
sum_2_num(50, 20)
作用：增加函数的 通用性，针对 相同的数据处理逻辑，能够 适应更多的数据
形参和实参
形参：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用
实参：调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的
返回值
1.返回值 是函数 完成工作后，最后给调用者的一个结果
2.在函数中使用 return 关键字可以返回结果
3.调用函数一方，可以 使用变量来接收函数的返回结果
# return 后续的代码都不会被执行
嵌套
def test1():
print("*" * 50)
def test2():
print("-" * 50)
test1()
print("+" * 50)
test2()
# 被嵌套的函数要提前定义
函数注释
函数本身注释：使用 连续的三对引号
参数注释：停留在函数名上，出现小灯泡，点击Insert documentation string stub
# 需要没有函数本身的注释才可以跳出选项，不然没有Insert documentation string stub选项
在 函数调用 位置，使用快捷键 CTRL + Q 可以查看函数的说明信息
模块
1.可以 在一个 Python 文件 中 定义 变量 或者 函数，然后在 另外一个文件中 使用import导入这个模块
2.导入之后，就可以使用 模块名.变量 / 模块名.函数 的方式，使用这个模块中定义的变量或者函数
# 模块名也是一个标识符
方法
# 方法 和函数类似，同样是封装了独立的功能
# 方法 需要通过 对象 来调用，表示针对这个 对象 要做的操作
Pyc文件
pyc文件是由 Python 解释器将 模块的源码 转换为 字节码，python这样保存 字节码 是作为一种启动 速度的优化
* Python 在解释源程序时是分成两个步骤的
1. 首先处理源代码，编译 生成一个二进制 字节码
2. 再对 字节码 进行处理，才会生成 CPU 能够识别的 机器码
* 有了模块的字节码文件之后，下一次运行程序时，如果在 上次保存字节码之后 没有修改过源代码，Python 将会加载 .pyc 文件并跳过编译这个步骤
* 当 Python 重编译时，它会自动检查源文件和字节码文件的时间戳
* 如果你又修改了模块的源代码，下次调用该模块的程序运行时，字节码将自动重新创建
04-高级变量类型（非字符型变量）
特点：
1.都是一个 序列 sequence，也可以理解为 容器
2.取值
3.遍历 for in
4.计算长度、最大/最小值、比较、删除
5.链接 + 和 重复 *
6.切片
列表（list）
定义
1.List（列表）是Python 中使用最频繁的数据类型，在其他语言中通常叫做数组，是一个有序的数据集合
2.列表用 [] 定义，数据之间使用 , 分隔
3.列表的索引从 0 开始
# 索引就是数据在列表中的位置编号，索引又可以被称为下标
列表的常用操作
1.增加
列表.insert(索引, 数据) #在指定位置插入数据
列表.append(数据) #在末尾追加数据
列表1.extend(列表2) #将列表2的数据追加到列表1
# A.extend(B) 返回 None，结果是 A 变成了 A + B，原因在于extend过程中先创建A列表，再接上B列表，并将A+B这个列表赋给A列表，而这个数组因为没有命名，所以被抛弃了，即返回None
2.修改
列表[索引] = 数据 #修改指定索引的数据
3.删除
del 列表[索引] #删除指定索引的数据
列表.remove[数据] #删除第一个出现的指定数据
列表.pop #删除末尾数据
列表.pop(索引) #删除指定索引数据
列表.clear #清空列表
4.统计
len(列表) #列表长度
列表.count(数据) #数据在列表中出现的次数
5.排序
列表.sort() #升序排序
列表.sort(reverse=True) #降序排序
列表.reverse() #逆序、反转
遍历
for 循环内部使用的变量 in 变量类型
循环内部针对列表元素进行操作
列表的应用场景
1.存储相同类型的数据
2.通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作
元组（tuple）
定义
1.和列表相似，但元素无法修改，且用（）定义
2.元组中只包含一个元素时，需要在元素后面添加逗号
# info_tuple = (50, )
元组的常用操作
元组.count(元素) #统计元素个数
元组.index(元素) #查找元素索引
len(元组) #统计元组包含的元素数
元组的应用场景
1.函数的 参数 和 返回值，一个函数可以接收 任意多个参数，或者 一次返回多个数据
2.格式字符串，格式化字符串后面的 () 本质上就是一个元组
# info = ("zhangsan", 18)
print("%s 的年龄是 %d" % info)
3.让列表不可以被修改，以保护数据安全
元组与列表之间的转换
1.元组转换成列表
list(元组) #返回列表
2.列表转换成元组
tuple(列表) #返回元组
字典（dict）
定义
1.字典是一个无序的数据集合，在平常使用过程中一般用来描述一个物体的具体信息，类似于C语言中的结构体(struct)，但输出字典时的顺序并不一定就是定义时的顺序
2.字典用 {} 定义，字典使用键值对存储数据，键值对之间使用 , 分隔
3.键 key 是索引，值 value 是数据，键和值之间使用 : 分隔
4.键必须是唯一的，值可以取任何数据类型，但键只能使用字符串、数字或元组
# eg:dict_student = {"name": "小明",
"age": 18,
"gender": True,
"height": 1.75,
"weight": 75.5}
print(dict_student)
字典的常用操作
1.取值
字典[key] #从字典中取值，不存在会报错
字典.get(key) #从字典中取值，不存在会报错
2.修改与新增
字典[key]=value #key存在会修改，不存在会新建
字典.setdefault(key,value) #key存在不修改，不存在会新建
3.合并
字典1.update(字典2) #将字典2的数据合并到字典1，存在相同key则覆盖原有value，不同则添加
4.删除
del 字典[key] # 删除指定键值对，key不存在会报错
字典.pop(key) # 删除指定键值对，key不存在会报错
字典.popitem() # 随机删除键值对
字典.clear #清空字典
5.显示数据
字典.keys() # 所有key列表
字典.values() # 所有value列表
字典.items() # 所有(key,value)元组列表
6.获取字典长度
len(字典) # 获取字典的键值对数量
字典的遍历
dict_xioaming = {"age": "18",
"height": "1.85",
"weight": "75"}
for i in dict_xioaming:
print("%s, %s" % (i, dict_xioaming[i]))
# 由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多
应用场景
1.使用多个键值对，存储描述一个物体的相关信息作为一个字典
2.将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理
list_student = [{"name": "小明",
"age": "18",
"rank": "1"},
{"name": "小刚",
"age": "19",
"rank": "2"}]
for dict_student in list_student:
for i in dict_student:
print("%s:%s" % (i, dict_student[i]))
字符串（str）
定义
1.字符串是表示文本的数据类型，可用单引号 ' 或者双引号 " 定义，多数使用双引号定义
2.可以用for遍历字符串中的每一个字符
# 英文
old_str = "Hello World"
for i in old_str:
print(i, end=" ")
# 中文
new_str = "你好，世界"
for j in new_str:
print(j, end=" ")
基本操作
字符串[索引] # 从字符串中取出单个字符
1.统计
len(字符串) # 统计字符串长度
字符串.count(字符串/字符） # 小字符串/字符在大字符串中出现的次数
字符串.index(字符串/字符) # 小字符串/字符第一次出现时的索引，若不存则报错
2.判断类型
string.isspace() # string中包含空格或者空白字符(\n\r\t)则返回True
string.isalnum() # string不为空且所有字符都是字母或数字则返回True
string.isalpha() # string不为空且所有字符都是字母则返回True
string.isdecimal() # string中包含全角数字（1、2、3）则返回True，不包括小数
string.isdigit() # string中包含全角数字、Unicode字符串(⑴、²)则返回 True，不包括小数
string.isnumeric() # string中包含全角数字、Unicode字符串、汉字数字(一千零一)则返回 True，不包括小数
string.istitle() # string是标题化的(每个单词的首字母大写)则返回 True
string.islower() # string中包含至少一个区分大小写的字符，并且都是小写，则返回 True
string.isupper() # string中包含至少一个区分大小写的字符，并且都是大写，则返回 True
3.查找与替换
string.startswith(str) # 若字符串以str开头则返回True
string.endswith(str) # 若字符串以str结束则返回 True
string.find(str, start, end) # 检测str是否包含在字符串中，范围是[start, end)，是则返回开始的索引值，否则返回-1
string.rfind(str, start, end) # 类似于find()，不过是从右边开始查找
string.index(str, start, end) # 跟find()方法类似，只是如果str不在 string会报错
string.rindex(str, start, end) # 类似于index()，不过是从右边开始
string.replace(old_str, new_str, num) # 把string中的old_str替换成new_str，如果num指定，则替换不超过num次，且不会改变原有字符串
4.大小写转换
string.capitalize() # 把字符串的第一个字符大写
string.title() # 把字符串的每个单词首字母大写
string.lower() # 转换所有大写字符为小写
string.upper() # 转换所有小写字母为大写
string.swapcase() # 翻转大小写
# 所有大小写转换均不改变原有字符串
5.文本对齐
string.ljust(width, fillchar) # 左对齐，并使用fillchar(默认为英文空格)填充至长度width的新字符串
string.rjust(width, fillchar) # 右对齐，并使用fillchar(默认为英文空格)填充至长度width的新字符串
string.center(width, fillchar) # 居中，并使用fillchar(默认为英文空格)填充至长度width的新字符串
6.去除空白字符
string.lstrip() # 截掉 string 左边的空白字符
string.rstrip() # 截掉 string 右边的空白字符
string.strip() # 截掉 string 左右两边的空白字符
7.拆分与拼接
string.partition(str) # 把字符串string分成一个3元素的元组 (str前面, str, str后面)
string.rpartition(str) # 类似于partition()方法，不过是从右边开始查找
string.split(str, num) # 以str为分隔符拆分string，如果 num 有指定值，则仅分隔出 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格，返回一个列表（即将字符串中的指定分隔符去掉，作为列表返回）
string.splitlines() # 按照行('\r', '\n', '\r\n')分隔，返回一个包含各行作为元素的列表
string.join(seq) # 以string作为分隔符，将 seq（序列）中所有的元素的字符串表示合并为一个新的字符串
切片
切片 方法适用于 字符串、列表、元组。顺序切从0开始，依次递增；倒序切从-1开始，依次递减
consequence[start_index: end_index: step]
区间范围为[start_index, end_index)
从头开始，start_index数字可以省略，冒号不能省略
到末尾结束，end_index数字可以省略，冒号不能省略
step默认为 1 ，如果连续切片，数字和冒号都可以省略
start_index：表示是第一个元素对象，正索引位置默认为0；负索引位置默认为 -len(consequence)
end_index：表示是最后一个元素对象，正索引位置默认为 len(consequence)－1；负索引位置默认为 -1。
eg:
num_str = "0123456789"
# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 从开始位置，每隔一个字符截取字符串
print(num_str[::2])
# 6. 从索引 1 开始，每隔一个取一个
print(num_str[1::2])
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
# 9. 字符串的逆序（面试题）
print(num_str[::-1])
print(num_str[-1::-1])
公共方法
内置函数
len(item) # 计算容器中元素个数
del(item) # 删除变量
max(item) # 返回容器中元素的最大值，如果是字典，只针对 key 比较
min(item) # 返回容器中元素的最小值，如果是字典，只针对 key 比较
# 字符串比较符合以下规则: "0" < "A" < "a" （具体字符大小参照ASCII码表）
运算符
+ 合并 字符串、列表、元组
* 重复 字符串、列表、元组
in 元素是否存在 字符串、列表、元组、字典
not in 元素是否不存在 字符串、列表、元组、字典
> >= == < <= 元素比较 字符串、列表、元组
# 注意
1. in 在对字典操作时，判断的是字典的键
2. in 和 not in 被称为成员运算符
3. + 不同于extend和append，+ 会生成新列表，而extend则是将数据追加到原列表，append则是将列表作为独立的元素插入原列表
for else
for 变量 in 集合:
循环体代码
else:
没有通过 break 退出循环，循环结束后执行的代码
应用场景
在迭代遍历嵌套的数据类型时，例如一个列表包含了多个字典，要判断某一个字典中是否存在指定的值
如果存在，提示并且退出循环；如果不存在，在循环整体结束 后，希望得到一个统一的提示
eg:
students = [
{"name": "阿土",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 75.0},
{"name": "小美",
"age": 19,
"gender": False,
"height": 1.6,
"weight": 45.0},
]
find_name = "阿土"
for stu_dict in students:
print(stu_dict)
if stu_dict["name"] == "阿土": # 判断当前遍历的字典中姓名是否为find_name
print("I find it!")
break # 如果已经找到，直接退出循环，不进入else语句对后续的数据进行比较
else:
print("I don't find it...")
print("Find over.")
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
