Python—②Python基础

Python—②Python基础

<<<CSDN排版不美观，想看排版美观的进Python—②Python基础>>>

1、Python基础

①注释
注释作用：
1、添加注释，增强可读性，方便自己一段时间之后或者其他人快速读懂代码
2、调试代码，当代码出现问题，先不要删除掉，而是注释掉
单行注释（行注释）：需要注释的内容前面加 #,不过为了保证良好的可读性，建议# 后面添加一个空格，然后再编写相应的注释,如果你#后面不加空格就写注释了，PyCharm会在你的注释下方画波浪线；还建议注释尽量添加在这行代码后面，不过需注意，为了保持可读性，代码和#中间留两个空格
例如：print(“世界 你好！”) # 第一个Python程序
可以利用智能代码格式化，PyCharm快捷键为Ctrl+Alt+L，会帮你快速格式化代码，调整成为规范格式；不过一般建议自己修改一下快捷键，因为其他很多软件快捷键也是这个，会起冲突。我本人改成了Ctrl+1。
多行注释（块注释）：如果编写的注释信息很多，一行无法显示，就可以使用多行注释，以连续的三个引号（单引号和双引号都可以）开始，并同样以三个引号结束，中间的内容即多行注释的内容
注释的代码不会运行

关于代码规范：
PEP（Python Enhancement Proposals）Python增强建议书
PEP 8 ,PEP第八篇文档专门针对 Python的代码格式 给出了建议
谷歌有对应的中文文档：https://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/contents/
谷歌对应的中文文档：https://www.python.org/dev/peps/pep-0008/
一定要注意编码的规范，因为这是合格的程序员的必要条件之一

②算术运算符
运算符 描述 实例

• 加 30+30=60

• 减 60-30=30

• 乘 3030=900
  / 除 15/4=3.75
  // 取整数 返回除法的整数部分（商） 9//2 结果为4
  % 取余数 返回除法的余数 9%2=1
  ** 幂 即次方，2**3=8
  扩展： 符号还可以用于字符串，计算结果就是字符串重复指定次数的结果
  例如：
  print("-" * 12) 和 print("------------") 效果相同

算术运算符优先级
运算符有优先级，优先级越高的先执行，低的后执行，同级运算符遵从从左到右的顺序，不过（）优先级别最高，因此可以通过（）调整优先级。
详细如下：
运算符 描述
** 幂（高优先级）

• / % // 乘 除 求余 取整（中优先级）

• • 加 减（低优先级）
    2+6*6=38

③程序执行原理
CPU（中央处理器，负责处理数据、计算）、内存（临时存储数据）、硬盘（永久存储数据）
安装的程序存储在硬盘中，执行的程序保存在内存中，所以当程序需要执行时，首先要被加载到内存中，CPU再执行内存中的代码
Python程序执行原理
操作系统首先会让CPU把Python解释器的程序复制到内存中
Python解释器会根据语法规则，从上到下让CPU翻译Python程序中的代码
CPU负责执行翻译完成的代码

④变量
1、变量的定义：
Python中，每个变量使用前都必须赋值，变量赋值后该变量才会被创建
= 赋值号
格式：变量名 = 值

变量的类型可以在debug的Variables中看得到
可以在调试中看到的四种类型：
int 整数、float 浮点数、str 字符串、bool 布尔（真true 假false）
在Python中不需要指定数据类型，Python会根据 = 右侧的值，自动推导出变量中存储数据的类型

数据类型可以分为数字型和非数字型
数字型：整型（int）、浮点型（float）、布尔型（bool）、复数型（complex）
其中复数型主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题

非数字型：字符串、列表、元组、字典
提示：在Python2.x中，整数根据保存数值的长度分为：整数（int）和长整数（long），Python3.x版本只有int

type(变量名字) 可以查看该变量的类型

数字型变量可以直接计算，布尔类型中true为1，false对应的数字为0
Python中，字符串之间可以使用 + 拼接成新的字符串
字符串变量 可以和整数使用 * 重复拼接成相同的字符串
提示：数字型变量和字符串之间不能进行其他计算

按标准是这样分的：
Python3 中有六个标准的数据类型：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

⑤输入输出
print(x) 输出x
type(x) 查看x类型
输入：input函数从键盘等待用户的输入
字符串变量 = input(“提示信息：”)
字符串变量=int(input(“提示信息：”)) >>> 直接将输入的字符串类型转化成为int型
字符串变量=float(input(“提示信息：”)) >>> 直接将输入的字符串类型转化成为float型

类型转换函数
int(x) 将x转换为一个整数
float(x) 将x转换为一个浮点数
str(x) 将x转换为一个字符串
注意：如果可以减少变量，尽量减少变量，因为变量都会占用空间

格式化操作符
如果需要文字和变量同时输出，就需要用到格式化操作符
包含 % 的字符串被称为格式化字符串
格式化字符 含义
%s 字符串
%d 有符号十进制整数，%06d表示输出的整数显示位数，不足的地方使用0补全
%f 浮点数，%.02f表示小数点后只显示两位
%% 输出%，百分号
语法格式：
print(“格式化字符串” % 变量1)
print(“格式化字符串” % (变量1，变量2…))
百分数输出
print(“百分数为 %.2f%%” % (x*100))

⑥标识符和关键字
关键字定义：Python内部已经使用的标识符，已经具有特定的功能和含义
关键字比如：import、input、print等等
代码：
import keyword
print(keyword.kwlist)
可以看到关键字有哪些

标识符定义：标识符基本可以理解为变量名和函数名
标识符由字母、下划线和数字组成
标识符规则：1、标识符不能以数字开头2、标识符不能与关键字重名

注意：Python中标识符区分大小写的
命名规则：
1、为了保证代码格式，= 的左右应该各保留一个空格
2、如果变量名由两个及多个单词组成，可以按照以下方式命名（这也是Python开发者吉多推荐的）：
a、每个单词都使用小写字母
b、单词与单词之间使用_下划线连接
c、例如：first_name、last_name等等

其他编程语言还有一种命名方式：驼峰命名法
如果变量名由两个及多个单词组成，驼峰命名法：
小驼峰命名方式：第一个单词以小写字母开始，后序单词的首字母大写，例如：firstNmae，lastName
大驼峰命名方式：每个单词的首字母都采用大写字母，例如：FirstName、LastName

⑦分支结构
if判断结构：
if 判断条件:
条件成立时，执行的代码
…
注意：代码缩进为一个 Tab 键，或者4个空格，不过Python强烈建议用4个空格，在Python中Tab和空格是不同的

关系（比较运算符）
运算符 描述
== 两边操作数是否相等，相等则条件成立返回true，否则返回else
!= 检查两边的操作数的值是否不相等，不相等则条件成立返回true，否则返回else

检查左操作数的值是否大于右操作数的值，左操作数大于右操作数则条件成立返回true，否则返回else
< 检查左操作数的值是否小于右操作数的值，左操作数小于右操作数则条件成立返回true，否则返回else
= 检查左操作数的值是否大于或等于右操作数的值，左操作数大于或等于右操作数则条件成立返回true，否则返回else
<= 检查左操作数的值是否小于或等于右操作数的值，左操作数小于或等于右操作数则条件成立返回true，否则返回else
Python2.x中判断不等于还可以使用<>运算符，Python3.x不支持<>表示不等于，数据库mysql推荐使用<>而不是!=
注意：Python if语句以及缩进部分是一个完整的代码块，所以缩进在Python中尤为重要
在PyCharm中，行数附近会有 开始标记 和 结束标记 方便看到if代码块的开始和结束
if、else判断结构：
if 判断条件:
条件成立时，执行的代码
…
else:
条件不成立时，执行的代码
…
注意缩进，四个空格，if和else各自缩进的部分共同是一个完整的代码块
而且当你鼠标放在放在if代码块中的时候，PyCharm可以看到当前代码块属于的if或者else，点击一下可以跳转到目标if或else

多组if、else判断结构：
if 条件1:
条件1成立时，执行的代码
…
elif 条件2:
条件2成立时，执行的代码
…
elif 条件3:
条件3成立时，执行的代码
…
else:
以上条件都不成立时，执行的代码
…
提示：elif是else if的缩写

if判嵌结构：
if 判断条件:
条件成立时，执行的代码
…
if 判断条件:
条件成立时，执行的代码
…
else:
条件不成立时，执行的代码
…
else:
条件不成立时，执行的代码
…
PyCharm缩进提示：PyCharm可以使用Tab统一进行缩进，选中需要缩进的代码，然后按下Tab键，就会统一缩进成相同的格式。按住Shift+Tab，可以统一减少缩进。

if如果后面无内容，可以输入 pass
比如
if a>b:
pass
⑦逻辑运算符
逻辑运算符用来连接两个表达式
运算符 逻辑表达式 描述
and x and y 布尔"与"，如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值
or x or y 布尔"或"，如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值
not not x 布尔"非"，如果 x 为 True，返回 False ；如果 x 为 False，它返回 True
简而言之：
and，需要x和y都为真，结果才为真，否则为假
or，需要x或y其中一个为真，结果就为真，否则为假
not，x为真，结果为假；x为假，y为真

⑧导入模块简介
例如，在Python想使用随机数，首先需要导入随机数的模块———即工具包
import random
导入模块后，可以直接在模块名称后 敲一个 . ，然后按 Tab键 ，会提示该模块中包含的所有函数
random.randint(a,b) ， 返回a - b中直接之间的整数，包含a和b，注意：a必须小于b
提示：将import导入包的语句写最前面，方便后面使用，也更符合格式规范要求

⑨循环
程序三大流程：顺序、分支、循环
while 判断条件:
循环执行语句
…
在编程中，一个靠自身控制无法终止的程序称为“死循环”
注意循环条件，避免死循环，死循环即

常见的技术方法有两种：
自然计数法：从1开始，更符合人类习惯
程序计数法：从0开始，更符合计算机这边的情况
因为希望在编写程序，除非特别的需求，否则循环的计数都从0开始

break和continue
break，当执行到break时，退出整个循环
continue，当执行到continue时，不执行后面的代码，进行下一次循环

print函数高级：
默认情况下，print函数输出后会在内容末尾增加换行，如果不希望增加换行，可以在print函数输出的内容后面增加, end=""
print() 为换行
print("\n") 为换两行
练习1：
打印如下内容：
*
**

---

---

---

代码：
row=1
while row<=5:
print("*" * row)
row+=1

转义字符：
所有的ASCII码都可以用“\”加数字（一般是8进制数字）来表示。而C中定义了一些字母前加""来表示常见的那些不能显示的ASCII字符，如\0,\t,\n等，就称为转义字符。
\n，换行(LF) ，将当前位置移到下一行开头
\t，是水平制表(HT) ，跳到下一个TAB位置
'，代表一个单引号（撇号）字符
"，代表一个双引号字符

⑩赋值运算符
运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a

⑪函数
函数就是将具有独立功能的代码封装成为一个小模块，方便下次使用时不必重新再把代码写一遍，提高了代码的复用性
格式：
def 函数名():
函数代码
…

其中def是英文define的缩写， 定义 的意思
函数名称 应该能够表达 函数封装代码 的功能，方便后序的调用，即名字取得有意义并且易懂
函数名称的命名应该符合 标识符的命名规则：
名称可由字母、数字和下划线组成
不能以数字开头并且不能和关键字重名

注意：
1、定义好的函数在调用时才会执行的
2、函数调用不能写在函数调用的上方，否则回报错 NameError:name ‘函数名’ is not defined

提示一下：
PyCharm Debug中 F8 Step Over，单步执行，会把函数调用看做一步执行
PyCharm Debug中 F7 Step Into，单步执行，会进入函数内部，执行函数内部一行一行代码

函数的文本注释
在开发中，给函数增加注释，可以增进函数的可阅读性
一般给函数增加注释，会定义在函数名字的下一行，使用 连续的三对引号 ，引号中间为对函数的文字说明
待会在调用函数时，按 Ctrl + q ，会显示函数的注释说明
添加注释的时候也可以 选择 Insert documentation string stub ，
一定要养成给函数添加文档注释的习惯

函数参数
def 函数名(参数一,参数二,…):
函数代码
…
待会调用函数的时候将参数传进去即可

形参和实参
形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部的

函数返回值
有时候在调用函数时，希望返回给调用者一个返回值，这时候就需要返回值，函数里用return关键字来返回，调用者调用该函数，就会产生这个return后的值
注意：return表示返回，后续的语句都不会执行，相当于无效
提示：函数也支持嵌套调用

⑫模块
模块暂时可以理解成工具包，需要使用就需要使用import导入该模块；每一个以py为后缀名的Python源代码文件都是一个模块；在模块中可以定义全局变量、函数 都是模块能够提供给外界直接使用的工具
导入后可以通过 模块.函数 或者 模块.变量 来调用
提示：模块名，及py的文件名，也是标识符，也最好遵守PEP8的规则
以上有点类似调用JAVA类中的成员变量和方法
⑬pyc
pyc 是一种二进制文件，是由py文件经过编译后生成的文件，py文件变成pyc文件后，加载的速度有所提高，而且pyc是一种跨 平台的字节码，是由python的虚拟机来执行的，这个是类似于JAVA虚拟机JVM的概念。
c是compiled 编译的 意思
pycache 目录可以看到是 Python解释器 将模块的源码转换成字节码文件

⑭高级变量
前面有讲过：
实际数据类型分为数字型和非数字型
数字型：整型（int）、浮点型（float）、布尔型（bool）、复数型（complex）
其中复数型主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
非数字型：字符串、列表、元组、字典
提示：在Python2.x中，整数根据保存数值的长度分为：整数（int）和长整数（long），Python3.x版本只有int

在Python中，所有非数字型变量都支持以下特点：
1、都是一个序列sequence，

（1）列表
List列表是Python使用最频繁的数据类型，相当于Java中的数组
专门用于存储一组信息；用[ ]定义，数据之间用 , 分割；列表的索引从0开始
比如如下代码:
nums=[9,8,7,6,5,4,3,2,1,0]
print(nums[0])
结果为 9
注意：nums[10]会报错>>>IndexError: list index out of range,因为超过了索引范围；其他类似操作都会发生超出索引范围错误

创建空列表
列表名=[]

列表常用方法：
列表.index(数据) >>> 查看该数据在该列表的索引 （如果数据不在列表中，将会报错 ValueError: 数据 is not in list）
增加：
列表.insert(索引,数据) >>> 在指定位置插入数据
列表.append(数据) >>> 在末尾追加数据
列表.extend(列表2) >>> 将列表2的数据追加到列表
修改：
列表[索引]=数据 >>> 修改指定索引的数据
删除：
del 列表[索引] >>> 删除指定索引数据 （del关键字是将变量从内存中删除，最好使用列表提供的方法）
列表.remove[数据] >>> 删除第一个出现的指定数据 （如数据不在列表中报错:ValueError: list.remove(x): x not in list）
列表.pop >>> 删除末尾数据
列表.pop(索引) >>> 删除指定索引数据
列表.clear >>> 清空列表
统计：
len(列表) >>> 列表长度
列表.count(数据) >>> 数据在列表中出现的次数
排序：
列表.sort() >>> 升序排列
列表.sort(reverse=True) >>> 降序排列
列表.reverse() >>> 逆序、反转

循环遍历：
遍历是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问；即从头到尾一次从列表中访问数据
迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果。每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值

for 实现迭代遍历:
for 循环内部使用的变量 in 列表:
循环内部针对列表元素进行操作
…
这个 “循环内部使用的变量” ，当每一次循环过程中，数据都会保存在该变量中

应用场景：
尽管Python的列表中可以存储不同类型的数据
但是在开发中，更多的是：
1、存储相同类型的数据
2、通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

（2）元组
元组（Tuple）与列表类似，不同之处在于元组中的元素不能修改，且元组用()定义
注意：当元组只有一个元素时，该元组类型（ type(元组) ）就是该元素类型
所以只包含一个元素时，需要在元素后面添加 , 逗号

方法：
元组[索引] >>> 取索引值
元组.count(数据) >>> 查看元组某个元素出现的次数
元组.index(数据) >>> 查看元组该数据的索引

循环遍历：
for 循环内部使用的变量 in 元组:
循环内部针对列表元素进行操作
…

应用场景：
1、元组中的元素数据类型一般不同，除非能够确定元组中的数据类型，否则一般不对元素进行循环遍历
2、函数的参数和发回执，一个函数可以接收任意多个参数或者一次返回多个数据
3、格式字符串，格式化字符串后面的()本质上就是一个元组
例如： print(“Hello World”)，括号内的就是元组
4、保护列表数据不被修改，以保护数据安全，例如将列表的数据转换成元组数据

元组和列表之间的转换：
1、用 list 函数可以将元组转换成列表
new_list=list(元组)
2、用 tuple 函数可以将元组转换成列表
new_tuple=tuple(列表)

⑮字典
字典Dictionary 是除列表以外Python之中最灵活的数据类型
字典与列表的区别：
列表是有序的对象集合；字典是无序的对象集合
字典用{}定义
字典使用 键值对 存储数据，键值对之间用 , 分隔；键 key 是索引，值 value 是数据；键和值之间使用:分割；键必须是唯一的；值可以取任何数据类型，但 键 只能使用字符串、数字或元组
字典通常用于：描述一个 对象 的相关信息
有时候输出的时候顺序可能和定义不一致，因为字典顺序本身就是无序的
尽量每一个键值对占一行，格式显得一目了然
字典常用方法：
增加与修改：
字典名[“键名”]=数据 >>> 增加数据或者修改数据（如果键名已存在，将会对原来的值进行修改）
字典名.setdefault(键,值) >>> 新增数据 （如果key存在，将不会修改数据；如果key不存在，则新增键值对）
取值：
字典名[“键名”] >>> 键名的值 （如果键名不存在，将会报错）
字典名.get(“键名”) >>> 键名的值 （如果键名不存在，不会报错，会显示None）
删除：
字典名.pop(“键名”) >>> 删除指定键值对 （如果键名不存在，将会报错）
del 字典[“键名”] >>> 删除指定键值对 （如果键名不存在，将会报错）
统计键值对的数量：
len(字典名)
合并字典：
字典名.update(新字典名)（如果旧字典中已经有新字典中的键值对存在，新键值对将会覆盖旧字典数据）
清空字典：
字典名.clear()

循环遍历字典
for 循环内部使用的’key的变量’ in 字典
print("%s:%s" % (key的变量,字典名[key变量]))
…
提示：在实际开发中，由于字典中每一个键值对保存数据的类型都不同，所以针对字典的循环遍历需求并不是很多
更多使用是：将多个字典一个列表中，再进行遍历，进行相同的处理
⑯字符串
字符串就是一串字符，是编程语言中表示文本的数据类型
Python可以使用 单引号’’ 或者 双引号"" 定义字符串
例如：输出 你叫什么"名字"
print(‘你叫什么"名字"’)
需要这样，但是也可以 ’ 或者 "
同样字符串也可以通过索引获取，索引也是从0开始:
str=“Pyhton”
for x in str:
print(x)
str[2]结果为 h

字符串常用方法：
先熟悉一下下列转义字符
\n 换行 >>> 将当前位置移到下一行开头
\r 回车 >>> 将当前位置移到本行开头
\t 水平制表 >>> （跳到下一个TAB位置）
\ >>> 代表一个反斜线字符’’’
’ >>> 代表一个单引号（撇号）字符
" >>> 代表一个双引号字符
? >>> 代表一个问号

字符串长度:len(字符串)
统计一个子字符串在该字符串出现的次数：字符串.count(“子字符串”)（如果字符串不存在，将会返回0）
查找子字符串第一次出现的位置：字符串.index(“子字符串”)（如果字符串不存在，将会报错）
1、判断类型：
string.isspace() >>> 如果string只包含空白字符，则返回 True（空白字符包括空格、回车、换行、水平制表符等）
string.isalnum() >>> 如果string至少有一个字符并且所有字符都是字母或数字则返回 True（小数不算；能判断大小写中文数字）
string.isalpha() >>> 如果string至少有一个字符并且所有字符都是字母则返回 True（小数不算；能判断大小写中文数字）
string.isdecimal() >>> 如果string只包含数字则返回True，全角数字 （ 小数不算）
string.isdigit() >>> 如果string只包含数字则返回True，全角数字、①、\u00b2 （小数不算）
string.isnumeric() >>> 如果string只包含数字则返回True，全角数字、汉字数字 （小数不算；能判断大小写中文数字）
string.istitle() >>> 如果string是标题化的（每个单词的首字母大写）则返回 True （以空格区分单词 ）
string.islower() >>> 如果string中包含至少一个区分大小写的字符，并且所有这些(区分大小写)字符都是小写，则返回 True
string.isupper() >>> 如果string中包含至少一个区分大小写的字符，并且所有这些(区分大小写)字符都是大写，则返回 True

2、查找和替换：
string.startswith(str) >>> 检查字符串是否以str开头，是则返回 True
string.endswith(str) >>> 检查字符串是否以str结尾，是则返回 True
string.find(str,start=0,end=len(string)) >>> 检查str是否包含在string中，如果start和end指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1（是返回要查找的字符串在该字符串首次出现的索引值 ）
string.rfind(str,start=0,end=len(string)) >>> 类似于 find()函数，不过不同的是从右边开始查找（返回要查找的字符串在该字符串首次出现的索引值，索引值也是从左边按0开始）
string.index(str,strar=0,end=len(string)) >>> 类似 find()函数，只不过如果str不在string会报错
string.rindex(str,strar=0,end=len(string)) >>> 类似 index()函数，不同的是从右边开始查找
string.replace(old_str,new_str,num=string.count(old)) >>> 把string中的old_str替换成new_str，如果num指定，则替换不超过num次（原字符串没有被替换，而是函数返回一个新的字符串 ）

3、大小写转换：
string.capitalize() >>> 把字符串的第一个字符大写
string.title() >>> 把字符串每个单词的首字母大写
string.lower() >>> 转换string中所有大写字符为小写
string.upper() >>> 转换string中的小写字母为大写
string.swapcase() >>> 翻转string的大小写

4、文本对齐：
string.ljust(width,fillchar) >>> 返回一个原字符串左对齐，并使用fillchar填充至长度width的新字符串,fillchar默认为空格
string.rjust(width,fillchar) >>> 返回一个原字符串右对齐，并使用fillchar填充至长度width的新字符串,fillchar默认为空格
string.center(width,fillchar) >>> 返回一个原字符串居中，并使用fillchar填充至长度width的新字符串,fillchar默认为空格

5、去除空白字符：
string.lstrip() >>> 截掉string左边（开始）的空白字符
string.rstrip() >>> 截掉string右边（末尾）的空白字符
string.strip() >>> 截掉string左右两边的空白字符

6、拆分和连接：
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中所有的元素（的字符串表示）合并为一个新的字符串

字符串切片
切片用于 字符串、列表、元组
切片使用 索引值 来限定范围，从一个大的字符串中切出小的字符串
列表和元组都是有序的集合，都能够通过索引值获取对应的数据
字典是一个无序的集合，是使用 键值对 保存数据的
字符串[开始索引:结束索引:步长]
注意几点：
1、指定的区间属于左闭右开，即包含开始索引不包含结束索引
2、从头开始，开始索引 数字可以省略，冒号不能省略
3、到末尾结束，结束索引可以省略，冒号不能省略
4、步长默认为1，如果连续切片，数字和冒号都可以省略（原字符串没有被替换，而是函数返回一个新的字符串；步长不能为0；如果将字符串反转，步长可以取-1，字符串[::-1],即可将字符串反转 ）
↑↑↑↑↑↑↑↑↑↑↑↑↑
字符串、列表、元组都支持切片，语法同上
↓↓↓↓↓↓↓↓↓↓↓↓↓
⑰公共方法
Python内置函数
len(item) >>> 计算容器中的元素个数
del(item) >>> 删除变量（del有两种: 1、del 列表[x] 2、del(列表[x]) 效果相同）
max(item) >>> 返回容器中元素的最大值（如果是字典，只针对key比较）
min(item) >>> 返回容器中元素的最小值（如果是字典，只针对key比较）
cmp(item1,item2) >>> 比较两个值 （字典不可以比较；python3.x已经取消com函数）
字符串比较符合以下规则: “0”<“A”<“a”，其实比较的是ASCII 码值

高级数据类型公共使用的运算符

• [1,2,3]+[2,3,4] 结果为 [1,2,3,2,3,4] 作用为合并，支持字符串、列表、元组（注意append和+的区别，例如 [1,2,3]+[2,3,4]和 [1,2,3].append[2,3,4])

• [“HH”]*4 结果为 [‘HH’, ‘HH’, ‘HH’, ‘HH’] 作用为重复，支持字符串、列表、元组
  in >>> 1 in(1,2,3) 结果为True 作用是判断元素是否存在，支持字符串、列表、元组、字典
  （in在对 字典 进行操作时，判断的是字典的键）
  not in >>> 4 not in(1,2,3) 结果为True 作用是判断元素是否不存在，支持字符串、列表、元组、字典

、>=、==、<、<= >>> (1,2,3)<(2,2,3) 结果为True，元素比较，支持字符串、列表、元组
in 和 not in 被称为 成员运算符
使用 in 针对列表判断，避免使用 or 。拼接复杂的逻辑条件，有时候不把用户的输入转化为int，这样可以避免如果用户转换的不是数字，导致程序报错

完整的for循环语法
for 变量 in 集合:
循环体代码
else:
没有通过break退出循环，循环结束后，会执行的代码
应用：
在 迭代遍历 嵌套的数据类型，当 循环遍历 时，找到该值则break，如果没找到，则else可以起作用。

⑱补充
1、TODO注释
TODO注释 #后面跟上空格，再跟上TODO，再跟上空格；用来标记需要去做的工作
格式： # TODO(作者/邮箱) 显示系统菜单

2、PyCharm重命名变量名：
右键该变量，然后点击Refactor

3、开发记得每个函数下面添加注释：
在PyCharm中，可以把鼠标放在需要添加注释的函数中，然后出现黄色小灯泡，然后点击Insert documentation string stub

4、Linux 上的 Shebang 符号(#!)
#!叫做”Shebang”或者”Sha-bang”
shebang通常在Unix系统脚本中的 第一行开头 使用，用来指明 执行这个脚本文件 的解释程序
如果脚本文件中没有#!这一行，那么它执行时会默认用当前Shell去解释这个脚本(即：$SHELL环境变量）
#! /usr/bin/xxx 写第一行，将会用该xxx去执行此脚本

5、变量进阶
id() 函数 可以查看变量中保存数据所在的内存地址
变量和数据都保存在内存中
在Python中，函数的参数传递以及返回值都是靠引用传递的
变量和数据分开存储，数据保存在内存，变量中保存着数据在内存地址，变量记录数据的地址，即引用
如果变量已经被定义，当给一个变量赋值时，本质是修改了数据的引用
例如
x=100
打印 id(x) 和 id(100) 地址将会一样

6、可变和不可变类型
不可变类型，内存中的数据不允许被修改：
数字类型：int、bool、float、complex、long（2.x版本支持）
字符串str
元组tuple
可变数据类型，内存中的数据可以被修改：
列表 list
字典 dict（字典的key只能使用不可变类型的数据）
可变类型的数据变化，是通过 方法 实现的

7、哈希（hash）
Pyhton中内置有一个名字为 hash(o) 的函数，可以接收一个不可变类型的数据作为参数，返回结果是一个整数
哈希是一种算法，作用为提取数据的特征码，唯一性
设置字典的键值对时，会首先对key进行hash已决定如何在内存中保存字典的数据，以方便后续对字典的操作：增、删、改、查
即：
键值对的 键key 必须是不可变类型数据，键值对的 值value 可以是任意类型的数据

8、全局变量和局部变量
局部变量是在 函数内部 定义的变量，只能在函数内部使用
全局变量是在 函数外部定义的变量，所有函数都可以使用这个变量
提示：一般不推荐使用全局变量，因为可变范围太大，而且生命周期太长，导致程序不好维护

局部变量的生命周期： 就是指变量从创建到被系统回收的过程；局部变量在函数执行时才会被创建；函数执行结束后，局部变量被系统回收；局部变量在生命周期内，可以用来存储函数内部临时使用到的数据；不同函数，可以定义相同的名字的局部变量，彼此不会有影响

全局变量和局部变量的执行顺序：函数执行时，需要处理变量时会，首先查找 函数内部 是否存在指定名称的局部变量，如果有，直接使用；如果没有，则查找函数外部是否存在指定名称的全局变量，有则使用全局变量；如果还没有，则报错

全局变量注意事项：
1、全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量
2、函数内部，可以通过全局变量的引用获取值，但是不可以直接修改全局变量的引用（使用赋值语句修改全局变量的值）
3、如果需要在函数内部修改全局变量的值，需要使用 global 关键字
4、为了保证所有函数都能够正确使用全局变量，应该将 全局变量定义在函数的上方
最好代码结构依次如下：
shebang
import 模块
全局变量
函数定义
执行代码
5、全局变量命名，为了避免和局部变量混淆，所以在定义全局变量，一遍增加g_或者gl_或者global_的前缀

9、函数返回值
函数返回值就是当该函数执行完后，return后可以跟返回结果，该值返回给调用函数的一方，调用函数的一方，同时也可以使用变量接收函数的返回结果

函数返回多个结果解决办法：
def 函数名：
…
return (元组)
可以用这种方式，但是这种在PyCharm中会在下面画波浪线，解决办法如下:
def 函数名：
…
return 值一、值二
Python会将这些值放入元组中，return返回的是一个tuple
接收的时候可以： 变量一、变量二 = 函数名
这样，该函数会将返回的元组的值一赋值给变量一，值二赋值给变量二 （注意事项：元组的长度需要和变量个数相等）

交换a,b两者值的方法：
（1）引入第三者变量：
c=a
a=b
b=c
（2）不引入第三者变量：
a=a+b
b=a-b
a=a-b
（3）利用位运算符并且也不引入第三者变量：
a=a^b
b=a^b
a=a^b
（4）Python独有并且不引入第三者变量
a,b=(b,a)
改进： a,b=b,a（注意事项：b,a也是元组）

10、函数参数
不可变和可变参数
无论是可变类型的参数还是不可变类型的参数，在函数内部，针对传入的形式参数使用 赋值语句 ，不会修改到外部的实参变量的值，可以看全局变量和局部变量存在的地址不同，然后去分析

如果是可变类型的参数，在函数内部 使用了 append() 等等方法修改了列表或字典 ，将会影响到全局变量的值
注意：在Python中，列表变量使用 += 本质上是在执行列表变量的 extend() 方法，不会修改变量的引用

11、缺省参数
定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫 缺省参数，缺省即默认
函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用

指定函数的缺省值
列表.sort() >>> 从小到大排列
列表.sort(reverse=True) >>> 从大到小排序
在定义函数时，参数先默认赋一个值，该值就是缺省值；如果后期有传新值，将会覆盖该值
缺省参数需要使用 最常见的值 作为默认值，如果一个参数的值不能确定，则不应该设置默认值，具体的数值由调用函数时传递
注意：
1、缺省参数的定义位置：必须保证 带有默认值的缺省参数在参数列表的末尾（并且最好带上参数名字，比如 列表.sort(Reserve=True) 而不是 列表.sort(True) ）
2、调用带有多个缺省参数的函数时，如果有多个缺省参数，需要制定参数名，这样解释器才能知道参数与传入值的对应关系
3、多值参数：有时候需要一个函数能够处理的参数个数是不确定的，这个时候，就可以使用多值参数，Python中有两种多值参数：
一、参数名前增加一个 * 可以接收元组，一般命名为：*args，存放元组参数
二、参数名前增加两个 * 可以接收字典，一般命名为：**kwargs，存放字典参数
args是arguments的缩写，参数的意思。Java也是这样的命名。
kw是keyword的缩写，kwargs可以记忆 键值对参数
一般 多值参数 的应用会出现在网络上一些民间开发者开发的框架中，了解一下有利于读懂他们写的代码

12、元组和字典的拆包
在调用带有多值参数的函数时，如果希望将一个元组变量直接传递给args或者将一个字典变量直接传递给kwargs，就可以使用拆包，简化参数的传递，拆包的方式是
一、在元组变量前，增加一个 *
二、在字典变量前，增加两个 **

13、函数的递归
函数调用自身的编程技巧称为递归
特点：函数在内部中调用自己
代码特点：递归过程中，代码相同，但是传入参数值不同；当参数满足某一个条件时，函数就不再执行，如果不设计条件将会出现死循环

比如求 1到num的和，用递归的算法：
def sum(num):
‘’‘累加递归’’’
if num==1:
return 1
return num+sum(num-1)
print(sum(100))
用递归的方法遍历整个文件目录结构，会非常简单