Python不是像C++一样通过{}来规定语句的范围，而是通过缩进来设定语句的范围，所以不要随意使用空格和Tab键
| 注释 | Python | C++ |
|---|---|---|
| 单行注释 | # 注释内容 | //注释内容 |
| 多行注释 | “”" 注释内容 “”"或’‘’ 注释内容’‘’ | /* 注释内容 */ |
加减乘除同C++
| 运算符 | 描述 | 示例 |
|---|---|---|
| // | 取整 | 返回除法的取整部分，9//2=4 |
| % | 取余 | 返回除法的余数，9%2=1 |
| ** | 幂 | 次方，2**3=8 |
注意：
字典中的键是唯一的，所以 “ * ” 不可用于字典
in 在对字典操作时，判断的是 字典的键
in 和 not in 被称为 成员运算符
成员运算符用于 测试 序列中是否包含396指定 成员
注意：在对 字典 操作时，判断的是 字典的键而不是值
条件1 and 条件2
if 条件1 and 条件2:
.... #条件1和条件2同时满足时的代码
条件1 or 条件2
if 条件1 or 条件2:
.... #条件1或条件2满足时的代码
not 条件
if not 条件:
.... #条件不成立时要执行的代码
定义一个变量在C++中需要先声明数据类型再敲变量名
但是在Python中不需要声明数据类型，直接： 变量名 = 初值 (变量名 = “字符串”) 即可
从0开始计数
使用赋值语句，就会修改地址
内存中的数据不允许被修改(即 修改的是地址)
int ， bool ， float ，complex ， long(2.x)strtuple内存中的数据允许被修改(即 地址不变，修改的是值)
listdict同C++一样：int，float，bool
Python有 复数型：complex
复数型主要用于科学计算
字符串，列表，元组，字典
非数字型变量的共同特点：
List(列表)是Python中最常用的数据类型 (就是数组)
与数组相同
列表用 [ ] 定义，数据之间用 “ , ” 分隔，索引从0开始
注意：从列表中取值时，若超过索引范围，程序报错
举例：
a_list = ["zhangsan" , "list" , "lisi"]
统计：
len.(列表) #获取列表的长度为 n+1
列表.count(数据) #数据 在列表中出现的次数
排序：
列表.sort() #升序排序
列表.sort(reverse=True) #降序排序
列表.reverse() #逆序
增
列表.insert(索引,数据) #在指定索引插入数据
列表.append(数据) #在末尾追加数据
列表.extend(列表2) #将列表2的数据追加到列表1
删：
del 列表[索引] #删除指定索引的数据
列表.remove[数据] #删除第一个出现的指定数据
列表.pop #删除末尾数据
列表.pop[索引] #删除指定索引的数据
列表.clear #清空列表
改：
列表[索引] = 数据 #修改指定索引的数据
查
列表.[索引] #从列表中取值
列表.index(数据) #获得数据第一次出现的索引
注意：
在Python中定义一个列表，例如：list[ ]，输入list. 就可以提示列表可以使用的方法
当你不知道这个方法是用来干什么的时候，你可以敲出来然后对着关键字按 Ctrl，就会出现方法的解释
举例：
list = [1,2,3,4,5,5,5,6,7,8,9]
print(list.count(5))
print(len(list))
i=0
list.insert(0,100)
while i<len(list):
print(list[i],end=" ")
i += 1
列表 = 列表 + 列表
即 列表 += 列表
本质上是调用 列表的extend方法
列表.extend(列表2) #将列表2的数据追加到列表1
Tuple(元组) 与列表类似，不同之处在于元组的 元素不能修改 ，可以和列表一样保存多种类型的数据
用于存储一串信息，数据之间用“ , ” 分隔
元组用 () 定义
元组的索引从 0 开始
举例：
tuple = ("zzz",1,1.0)
for a in tuple:
print(a)
Python给元组提供两个方法:
元组名.count #数据 在元组中出现的次数
元组名.index #数据 在元组中的索引
格式化字符串举例：
info_tuple = ("张三",20,1.75)
print("%s 年龄是 %d 身高是 %.02f" % info_tuple)
或者：
info_tuple = ("张三",20,1.75)
print("%s 年龄是 %d 身高是 %.02f" % info_tuple)
info_tuple2 = "%s 年龄是 %d 身高是 %.02f" % info_tuple
print(info_tuple2)
list1 = [1,2,"zhangsan",1.5] #定义个列表
info_tuple = ("张三",20,1.75) #定义个元组
info_tuple2 = tuple(list1) #把列表的值拷贝给一个元组
print(type(info_tuple2)) #打印类型
list2 = list(info_tuple) #把一个元组的值拷贝给列表
print(type(list2)) #打印类型
dictionary(字典)是除列表外Python中最灵活的数据类型
字典同列表、元组一样可以存储多个数据，通常用于描述一个物体的相关信息
和列表的区别：
字典用 { } 定义
字典使用 键值对 存储数据
举例：
zhangsan = {
"name":"zhangsan",
"gender":True,
"height":1.80
}
print(zhangsan)
常用方法：
len(字典名) #获取字典的 键值对数量
字典.keys() #所有的key列表
字典.values() #所有的value列表
字典.items() #所有的(key , value)元组列表
取值： #这三种方法如果取的键是不存在的，程序会报错
print(字典["键名"]) #比如：print(zhangsan["name"])
增加/修改：
字典["键名"] = 值 #比如：zhangsan["age"] = 18
删除：
字典.pop("键名") #比如：张三.pop("age")
合并字典：
字典1.update(字典2) #注意：如果被合并的字典中有数据冲突，则会覆 # 盖原有的键值对
清空字典：
字典.clear()
注意：
在Python中定义一个字典，例如：list{ }，输入list. 就可以提示列表可以使用的方法
当你不知道这个方法是用来干什么的时候，你可以敲出来然后对着关键字按 Ctrl，就会出现方法的解释
举例：
zhangsan = {
"name":"zhangsan",
"age":18,
"gender":True,
"height":1.80
}
for a in zhangsan:
print("%s %s" % (a,zhangsan[a])) #字典的遍历，前者是键，后者是值
print(zhangsan.items())
print(zhangsan.keys())
尽管可以用for in遍历字典
但是在开发中，更多的应用场景是：
card_list = [
{"name":"张三",
"age":"18",},
{"name":"李四",
"age":"20",}
]
for a in card_list:
print(a)
可以使用单/ 双引号 定义字符串，但是大部分常用双引号 " "
只有在字符串中引用才用单引号，比如： str = '它的外号叫"大黄" '
字符串的索引由0开始，可以通过索引获取字符串中指定位置的字符
也可以用for遍历 字符串中的每一个字符
操作：
字符串长度：
len(字符串) #获取字符串长度
小字符串出现次数：
字符串.count("小字符串") #小字符串在大字符串中出现次数
提取单个字符：
字符串[索引]
小字符串第一次出现的索引：
字符串.index("小字符串")
注意：
在Python中定义一个字符串，例如：str = " "，输入list.` 就可以提示列表可以使用的方法
当你不知道这个方法是用来干什么的时候，你可以敲出来然后对着关键字按 Ctrl，就会出现方法的解释
切片 方法适用于 字符串、列表、元组
切片的说明：
注意：
1. 指定的区间属于 左闭右开，[开始索引，结束索引) --> 开始索引<= 范围 <结束索引
2. 从头开始，开始索引 数字可以省略，冒号不能省略
3. 到末尾结束，结束索引的数字可以省略，冒号不能省略
4. 步长默认为1，如果连续切片，数字和冒号都可以省略
语法：#开始/结束索引划定范围，步长是指跳跃的步长，从开始/结束索引根据步长来得到一个小字 #符串
字符串[开始索引:结束索引:步长]
举例：
str = "0123456789"
#截取2345
print(str[2:6:1])
#截取2-末尾
print(str[2::])
#截取开始-5
print(str[:6:])
#截取完整字符串
print(str[::])
#从开始每个一个字符取一个
print(str[::2])
#字符串逆序
print(str[-1::-1])
| 函数 | 说明 |
|---|---|
| int(x) | 将x转换为整数 |
| float(x) | 将x转换为浮点数 |
| 转义字符 | 描述 |
|---|---|
| \ | 反斜杠符号 |
| \’ | 单引号 |
| \" | 双引号 |
| \n | 换行 |
| \t | Tab |
| \r | 回车 |
| 操作 | Python | C++ |
|---|---|---|
| 输入 | 字符串变量 = input(“提示信息”) | cin |
| 输出 | print(x) | cout |
input直接输入的话是字符串类型，可以用int强制转换
% 称为 格式化操作符 ， 专门用于处理字符串中的格式
与C的打印函数类似
| 格式化字符 | 含义 |
|---|---|
| %s | 字符串 |
| %d | 有符号十进制整数，%06d 表示输出输出的整数显示位数，不足的地方用0补全 |
| %f | 浮点数，%.02f 表示小数点后只显示两位 |
| %% | 输出% |
语法格式：
print("格式化字符" % 变量1)
print("格式化字符" % (变量1,变量2.....))
举例：
print("My name is %s，你好！" % name)
print("苹果的单价是 %.02f 元/斤，购买 %.02f 斤，需要支付 %.02f 元" % (price,weigth,money))
print("成绩及格的占比在 %.02f%% " % (scale*100))
在默认情况下，print函数输出内容后，会自动在末尾添加换行
如果不希望换行，则可以在内容后面加：end = “”
语法：
print("*",end="") #表示在print输出内容后，继续希望显示的内容
import keyword
print(keyword.kwlist)
#这两行代码可以查看Python中的关键字
# 不能定义与关键字相同名字的标识符
格式：
if 要判断的条件:
代码..... #条件 成立 时要做的事情
else:
代码..... #条件 不成立 时要做的事情
注意：代码缩进为一个tab键，或者4个空格，建议使用空格
Python开发中，tab和空格不要混用
举例：
age =18
if age >= 18:
print("成年")
else:
print("未成年")
C++中有
if
else if
else if.....
Python中有
if 要判断的条件:
代码..... #条件 成立 时要做的事情
elif 要判断的条件:
代码..... #否则
elif 要判断的条件： #否则
注意点： 缩进是有要求的，内层if-else前要有tab，print要有两个tab
age =10
if age >= 18 :
print("成年")
if age >= 18 and age>50 and age<60:
print("中年")
else:
print("老年")
else :
print("未成年")
语法： #条件的几种形式
while 条件(判断 计数器 是否达到 目标次数):
代码.......
处理条件(计数器+1)
举例：
i=1
while i<=5:
print("Hello World")
i += 1
print("i = %d" % i)
i=0
while i<=10:
i += 1
if i == 5:
break
print("i = %d" % i)
Python 没有 自增和自减 i++，i–
同C++一样，continue：退出当前循环，break：退出整个循环
语法： #条件的几种形式
while 条件1(判断 计数器 是否达到 目标次数):
代码.......
while 条件2
代码.....
处理条件2
处理条件1
举例：九九乘法表
k = 1
while k<=9:
j = 1
while j<=k:
print("%d * %d = %d " % (k,j,k*j),end="")
j += 1
print("")
k += 1
Python中为了提高列表的遍历效率，专门提供的迭代iteration遍历，使用for实现
列表、元组、字典都可以用
语法：
for 变量名 in 列表:
print("" % 变量名)
解释：顺序的方式从列表中依次获取数据，每次循环过程中，数据都会保存在变量中
举例：
list = [1,2,3,4,5,5,5,6,7,8,9]
for a in list:
print("%d" % a)
完整的for循环语法：
语法： #循环遍历完成才能进行else，break是中途退出了，所以不会进行else
for 变量名 in 集合:
循环体代码
else:
(没有通过break退出循环)循环结束后，会执行的代码
类比C++的头文件
import random
random. 就会提示该模块包含的所有函数
例如：
random.randint(a,b) #返回[a,b]之间的整数
random.randint(12,20) #生成12-20的随机数
random.randint(10,10) #结果永远是20
random.randint(10,5) #语句错误，必须 a<=b
导入：
import 模块名1
import 模块名2
导入之后： #当模块名过长时，可以起别名
import 模块名1 as 模块别名
调用：
通过 模块名. 使用模块提供的工具-->全局变量、函数、类
如果希望 从某一个模块中，导入 部分工具，就可以使用 from...import 方式
导入：
from 模块名1 import 工具名 (as 别名)
导入之后：
不需要通过 模块名. 访问
可以直接使用模块提供的工具-->全局变量、函数、类
注意：如果两个模块，存在同名函数，那么后导入的会覆盖先前导入的函数
若发现冲突，可以用as关键字给其中一个工具起别名 来解决这个问题
概念：
__init__.py优点：
使用 import 包名 可以一次性导入包中所有模块
举例：
程序1：
def m_table(): #该行包含函数
i = 1
while i<=9:
j = 1
while j<=i:
print("%d * %d = %d " % (i,j,i*j),end="")
j += 1
print("")
i += 1
程序2： #程序2中可以调用程序1的函数
import h_九九乘法表
h_九九乘法表.m_table() # 在某个位置根据需要调用该句
说明：
每个扩展名为py的Python源代码都是一个模块
在模块中定义的 全局变量、函数 都是模块能够提供给外界直接使用的工具
如果一个模块中定义了多个函数，在另一个程序中调用时，可以用 Ctrl+Q 来查看模块
调用一个模块之后，模块名就是标识符，模块名不能是数字开头
调用方式：
在另一个文件中使用 import 导入模块
使用 模块名.变量 / 模块名.函数 的方式调用变量或函数
先定义再调用
语法：
def 函数名(参数):
封装代码
.......
def 是 define 的缩写
举例：
def say_Hello(): #定义函数
i=0
while i<5:
print("Hello")
i += 1
say_Hello() #调用函数
def sum(a,b):
return a+b
a = 10
b = 5
print(sum(a,b))
函数的形参可以缺省(即给形参赋值)，但是缺省参数必须在参数列表末尾
def infor(name , age = 18 , gender) #错误
def infor(name , gender, age = 18 ) #正确
有时一个函数处理的参数个数是不确定的，这时候就可以用多值参数
Python 中有两种多值参数
def demo(*args, **kwargs):
print(args)
print(kwargs)
#接收若干个参数
args = {1,2,3,4,5}
kwargs = {"name" : "小明","age":18,"gender":True}
demo(*args , **kwargs)
控制台输出内容：
(1, 2, 3, 4, 5)
{'name': '小明', 'age': 18, 'gender': True}
一个函数执行后返回多个结果的方式 元组
元组可以包含多个数据，因此可以使用元组让函数一次性返回多个值
def infor():
name = "张三"
age = 20
return name,age #如果返回类型是元组，则小括号可以省略
result = infor()
print(result) #全部打印
print(result[0]) #打印name
print(result[1]) #打印age
#如果返回类型是元组，也可以用多个变量，来依次接收函数的返回结果
#同时变量次数要和元组中的元素个数相同
gl_name,gl_age = infor()
print(gl_name)
print(gl_age)
如果传递的参数是 可变类型 ，则在函数内部通过方法修改形参，可以导致实参值改变
举例：
def demo(list): #列表 可变
list[0] = 1000
list.append(500)
print(list)
list = [1,2,3]
demo(list)
print(list)
def demo1(num): #int 不可变
num = 1000
print(num)
num = 10
demo1(num)
print(num)
Python的递归函数和C++有所不同，Python中需要手动敲入递归出口，否则会出现死循环
def sum_numbers(num):
print(num)
#递归出口
if num == 1:
return
sum_numbers(num-1)
sum_numbers(3)
举例：递归求和
def demo(num):
if num == 1:
return 1
result = demo(num-1)
return result + num
a = int(input())
result = demo(a)
print(result)
注意：字符串的比较符合规则： “0” < “A” <“a”
list = [1,2,3,5,100]
print(max(list)) # 100
切片支持的数据类型：字符串、列表、元组
说明：
Python中 函数 的 参数传递 以及 返回值 都是靠引用传递的
注意：如果变量已被定义，当给一个变量赋值的时候，本质上是修改了数据的引用
变量不再对应之前的数据引用，而是改为对新赋值的数据引用
举例：
def test(num):
print(id(num))
a = 10
print(id(a))
print(id(10)) #a 和 num 指向 10的地址
test(a)
a = 20
print(id(a)) #a 和 num 指向 20的地址
print(id(20))
test(a)
调用test函数，本质上传递的是实参保存数据的引用，而不是实参保存的数据
与C++相同
定义在 函数内部 的变量，且只能在函数中使用，叫局部变量
定义在 函数外部 的变量，且所有函数都可以使用，叫全局变量(大多不使用)
不同函数，定义名字相同的局部变量，彼此之间无影响
定义并赋值给全局变量后，如果在函数体中给全局变量重新赋值，其本质是创建一个同名的局部变量并赋值，全局变量的值实际并未改变
全局变量值修改方式： 关键字 global
num = 10 #定义全局变量
def demo():
global num #给全局变量重新赋值
num = 99
操作文件的三个步骤：
| 序号 | 函数/方法 | 说明 |
|---|---|---|
| 1 | open | 打开文件，并且返回文件操作对象 |
| 2 | read | 将文件内容读取到内存 |
| 3 | write | 将指定内容写入文件 |
| 4 | close | 关闭文件 |
open 函数 负责打开文件，并且返回文件对象
read/write/close 方法都需要通过 文件对象 来调用
open 函数的第一个参数是要打开的文件名(区分大小写)
如果文件 存在，返回文件操作对象
如果文件 不存在 ，会 抛出异常
read 方法可以一次性 读入 并 返回 文件的 所有内容
close 方法用于 关闭文件 ，否则会造成资源消耗
注意：方法执行后，会把 文件指针 移动到 文件的末尾
#1.打开
file = open("reader.txt")
#2.读取
text = file.read()
print(text) #打印出reader文本文件中的所有信息
#3.关闭
file.close()
注意：在开发中，通常先把 打开 和 关闭 代码
文件指针
文件指针 标记 从哪个位置开始读取数据
第一次打开文件时，通常文件指针指向文件的开始位置
当执行了 read 方法后，文件指针 会移动到 读取内容的末尾
默认情况下会移动到文件末尾
执行了一次read后，因为指针指向了文件末尾，所以再使用一次read方法，就不会再读取内容了
read方法 默认会把文件的 所有内容 一次性读取到内存
如果文件太大，对内存的占用会非常严重
readline方法
readline 方法可以一次读取一行内容读取大文件的方式：
#打开文件
file = open("reader.txt")
while True:
#读取一行内容
text = file.readline()
#判断是否读取到内容
if not text:
break
#每读取一行的末尾已经有了一个换行符
print(text,end="")
#关闭文件
file.close()
open 函数 默认以 只读方式 打开文件，并且返回文件对象
语法：
f = open("文件名" , "访问方式")
举例：
file = open("reader.txt","a")
file.write("Hello Python")
file.close()
文件的复制
#小文件
#打开
file_read = open("reader.txt")
file_write = open("reader1.txt","w")
#读、写
text = file_read.read()
file_write.write(text)
#关闭
file_read.close()
file_write.close()
#大文件
#打开
file_read = open("reader.txt")
file_write = open("reader1.txt")
#读、写
while True:
#读取一行
text = file_read.readline()
#判断是否读取到内容
if not text:
break
file_write.write(text)
#关闭
file_read.close()
file_write.close()
在 终端/文件浏览器 中可以执行常规的 文件/目录 管理操作，例如：
创建、重命名、删除、改变路径、查看目录内容…
在Python中，如果希望通过程序实现上述功能，需要导入os模块
文件操作：
| 序号 | 方法名 | 说明 | 示例 |
|---|---|---|---|
| 1 | rename | 重命名文件 | os.rename(源文件名 , 目标文件名) |
| 2 | remove | 删除文件 | os.remove(文件名) |
目录操作：
| 序号 | 方法名 | 说明 | 示例 |
|---|---|---|---|
| 1 | listdir | 目录列表 | os.listdir(目录名) |
| 2 | mkdir | 创建目录 | os.mkdir(目录名) |
| 3 | rmdir | 删除目录 | os.rmdir(目录名) |
| 4 | getcwd | 获取当前目录 | os.getcwd() |
| 5 | chdir | 修改工作目录 | os.chdir(目标目录) |
| 6 | path.isdir | 判断是否是文件 | os.path.isdir(文件路径) |
注意：文件或目录操作都支持 相对路径 和 绝对路径