环境安装#
- 进入'https://www.jetbrains.com/pycharm/' 下载 pycharm 并安装。
- 根据引导安装应用并登录，创建你的第一段 python 代码。
差异#
- 毋庸置疑，py 比 cpp 更简单，写代码形式上亦是如此，大体上差别如下：
-
- 不需要头文件
-
- 主函数没有函数名
-
- 不需要 {}
-
- 不需要；
-
接下来，从最简单的输出开始；
基本知识#
输入输出#
输出函数 print () 语法就是：
print()
输入函数是 input ()，功能是接收用户输入的内容，语法是：
input（输出的内容）
举例：接收用户输入的密码并打印:
n = input("请输入密码：") #把输入内容赋给n，用 n 接收一下
print(n) #打印n
在 Python 里，“#” 表示注释，“#” 后面的东西不会被执行。
提示信息
请输入密码：123
123
变量#
- 合法的标识符：大小写字母，数字 (不能开头), 下划线。
- 没有长度限制。
建议望文生义，函数名、变量名等命名方法各有区分：
1. 包名：全小写，例如 time ;
2. 类名：每个单词的首字母大写，其他的小写，简称大驼峰命名，例如 HelloWorld ；
3. 变量名/函数名:第一个单词的首字母小写，后面的单词的首字母大写，简称小驼峰命名，例如 helloWorld ；
4. 常量：全大写，例如 HELLO 。
5. 其他命名方式，比如 hello_world 。
数据类型#
与 c++ 不同，python 不需要类型说明符，在设置时会自行分配。（不是没有！！！）
- 整型
- 浮点型
- 字符串
- bool 类型
- None 是一个单独的数据类型
- 列表、元组、字典、集合也是常见的数据类型
- 类型转换：
int() #被转换的必须为全数字的字符串
str()
float() #被转换的必须为全数字的字符串
- 获取类型信息
type() #返回的是对象的类型
type().__name__
sinstance(,) #常用来判断数据类型,返回bool
例子：
f = 30
print(type(f))
print(type(f).__name__)
print(isinstance(f,int))
输出：
f = 30
print(type(f))
print(type(f).__name__)
print(isinstance(f,float))
运算符#
运算符可以分为很多 4 类
- 一般运算符
+，-，*，/（真除法）,//（地板除，舍去小数部分）,%（取余数）,**（幂运算）
- 赋值运算符
=,+=，-=，*=，/=,%=,**=
连续赋值：a=b=c=d=10
- 布尔运算符
== （等于），！=（不等于）, >= ,<= ,>, <
4. 逻辑运算符
主要有 not、and 和 or 三类，又称非、与和或
and：前后都为真则为真
or：有一个为真则为真
not: 非真，非假
例子：
a = 10
b = 20
c = 30
d = 40
n1 = a > b and a < c #a>b为假，a<c为真，假与真为假
n2 = not a < c #a<c为真，非真则为假
n3 = a > b or a < c #a>b为假，a<c为真，假或真为真
print(n1,n2,n3)
输出；
False False True
流程控制#
条件分支 (if elif else)#
例子：
s = int(input("请输入分数:"))
if 80 >= s >= 60:
print("及格")
elif 80 < s <= 90:
print("优秀")
elif 90 < s <= 100:
print("非常优秀")
else:
print("不及格")
if s > 50:
print("你的分数在60分左右")
else:
print("你的分数低于50分")
输出：
请输入分数:55
不及格
你的分数在60分左右
循环流程#
- while 循环
语法：
while 布尔表达式:
代码块
只要条件 (布尔表达式) 为真就执行里面的代码块。
举例：比如说输入一个整数并计算各个位和，例如输入 321，那么各个位之和则为 6。
# 请输入一个整数，并计算各个位和 如：321=6
n = int(input("请输入一个整数:")) # 将字符串转为整型
# sums累加器：m=10 m=10+5
sums = 0
while n != 0: # 32 #3
sums = sums + n % 10 # sums=1+2=3+3=6
n = n // 10 # 32
print(sums)
输出：
请输入一个整数:2345
14
- for 循环
语法：
for 变量 in 可迭代对象:
代码块
例子：
l=[3,2,1]
for n in l:
print("1")
输出：
1
1
1
- range
for 循环经常会搭配 range 来使用，range 是一个可迭代对象，range 的语法如下：
range(start=0,stop,step=1)
Range 对象返回一个对象，该对象按步生成从开始 (包含) 到结束 (排除) 的整数序列。Range (i, j) 产生 i, i+1, i+2，…j - 1。Start 默认为 0,stop 省略！
Range (4) 产生 0,1,2,3。这些正是包含 4 个元素的列表的有效索引。
当给出 step 时，它指定增量 (或减量)。
- continue break
continue 跳过本次循环，后面的循环继续执行
break 终止循环
列表 (List)#
列表是可以同时存放任何数据，包括整型，浮点型，字符串，布尔型等等，是常用的数据类型之一。
列表的创建#
列表也是一个可迭代对象
1. 普通形式
l = [1,2,3,4,5] ---整型列表
l = ["a","b","c"] ---字符串列表
l = [True,False,1>2,5<6]---布尔列表
2. 混合列表
l = [1,2.5,"a",True]
3. 空列表
l = []
从列表中获取数据#
列表是有下标的，并且下标从 0 开始，获取方法类似数组
但是列表的下标正序从 0 开始，倒叙从 - 1 开始
print (List) 顺序输出整个列表
列表中数据交换#
例子：
l = [1, 2, 3, 4, 5] # 下标/索引：0开始
l[2], l[3] = l[3], l[2]
print(l)
Output:
[1, 2, 4, 3, 5]
向列表添加元素#
append(project) #列表尾插对象（作为整体）
extend(project) #列表尾插可迭代对象 eg：两列表相连接
insert(num,project) #指定下标位置添加对象（作为整体）
列表删除元素#
clear()#清空列表（列表还在，没被删除）
pop()#删除下标指定的元素，如果不加下标则删除最后一个元素
remove()#删除（正序第一个）指定的对象
del()#删除变量(整个列表)或列表指定下标元素的值（补位）
例子:
l = [1, 2, 3, 4, 5]
l2=[6, 7, 8, 9, 10]
l.extend(l2)
print(l)
l.append(l2)
print(l)
l.insert(3,l2)
print(l)
l.pop(1)
print(l)
l.remove(l2)
print(l)
del l[-1]
print(l)
del l
print(l2)
l2.clear()
print(l2)
Output
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, [6, 7, 8, 9, 10]]
[1, 2, 3, [6, 7, 8, 9, 10], 4, 5, 6, 7, 8, 9, 10, [6, 7, 8, 9, 10]]
[1, 3, [6, 7, 8, 9, 10], 4, 5, 6, 7, 8, 9, 10, [6, 7, 8, 9, 10]]
[1, 3, 4, 5, 6, 7, 8, 9, 10, [6, 7, 8, 9, 10]]
[1, 3, 4, 5, 6, 7, 8, 9, 10]
[6, 7, 8, 9, 10]
[]
修改元素#
同数组。
列表高级特性#
切片操作#
切片，顾名思义就是把 1 个列表切分为多个列表，语法如下：
变量[起始下标:结束下标] #结束下标取不到
做切片操作时要注意以下几个点：
- 如果下标从 0 开始可以省略不写，例如 n = l [:4]。
- 如果结束下标取的是最后一个元素，可以省略不写，例如 n = l [3:]。
- 如果列表中的元素都要，开始和结束下标都可以省略，例如 n = l [:]。
- n = l [:-1] 表示从 0 开始 - 到数二个元素。
例子：
l = [1, 2, 3, 4, 5]
print(l[0:4])
Output
[1, 2, 3, 4]
等距抽取#
方法是 n = l [开始：结束：步长] ，这个方法既可以正向去操作列表，也可以反向去操作列表，例如:
l = [1, 2, 3, 4, 5]
n = l[-1:-3:-1]
print(n)
Output
[5, 4]
列表的一些操作符#
比较运算符#
列表之间进行比较，以相同下标进行比较，从小到大进行比较，如果值相同则比较下一组元素，如果不同直接出结果，例如：
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 下标/索引：0开始
l2 = [2, 3, 4, 6]
print(l < l2) # True
Output
True
逻辑运算符#
逻辑运算符 and not or 跟比较运算符相似，返回结果都是布尔值（True/False）
拼接运算符#
拼接运算符是 + ，常用来进行两个列表拼接
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 下标/索引：0开始
l2 = [2, 3, 4, 6]
print(l + l2)
重复操作符#
重复操作符为 * ，后面常跟数字，表示将列表里面的元素重复复制几遍
l2 = [2, 3, 4, 6]
print(l2*2)
成员关系操作符#
成员关系操作符主要有 in 和 not in，用来判断元素是否在列表中，返回结果是布尔值
l = [2, 3, 4, 6]
print(5 not in l) #输出“5不在列表l中”这句话的真假
执行结果
True
列表的其他方法#
copy()#浅拷贝
count(project)#返回对象在列表中出现的次数
index(value,开始下标,结束下标)#元素出现的第一次下标位置，也可自定义范围
reverse()#原地翻转
sort (key=None reverse=False)#快速排序，默认从小到大排序，key:算法
len()#获取列表长度
二维列表#
#变量[外层列表下标][内层列表的下标]
l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for i in l:
for j in i:
print(j)
Output
1
2
3
4
5
6
7
8
9
元组（tuple）#
元组的创建及访问#
元组用（）的形式，是可迭代对象，是有序的，下标操作，支持切面操作 [:]
同列表，不再赘述。
修改和删除#
元组是不可变类型，不能修改，但是可以通过将元组转换成列表的形式进行修改和删除等操作，最后再将列表转换成元组，完成元组的修改和删除。
例如：修改元组中的元素:
t = (1, 2, 3, 4, 5)
l = list(t) #将元组转换成列表
print(l) #输出列表
l[2] = 6 #列表指定元素的修改
print(l) #输出新列表
t = tuple(l) #列表转换成元组
print(t)
Output
[1, 2, 3, 4, 5]
[1, 2, 6, 4, 5]
(1, 2, 6, 4, 5)
元组的操作符#
元组同样也有着操作符，方法跟列表的操作符是一样的，不再赘述。
元组的方法#
对其操作先转换成列表再行操作，不再赘述。
另外有两种方法新增：
1. count(value)
#统计某个值出现的次数，value是指定的值
2. index(value,[start],[stop])
#返回value在元组中(start到stop间)出现的下标位置（第一次出现的下标）
字符串#
在 Python 中，字符和字符串没有区别。可用 ' ' 也可以是 " "
字符串的特点#
1. 字符串不可变类型
2. 字符串是可迭代对象
3. 字符串支持索引和切片操作
4. 支持操作符;
拼接：+
重复操作符：*
比较运算符： > < <= >= == !=
逻辑运算符：not and or
成员关系： in not in
字符串的方法#
capitalize()#把字符串的第一个字符改为大写，后面的小写
casefold()#把整个字符串都小写
encode()#编码 str--bytes (二进制字符串)
decode()#解码
count(sub,start, stop)#返回字符(sub)出现的次数，star: 开始下标，stop:结束下标
find(sub,start,stop)# 返回sub第一次出现的下标,查不到返回-1
index(sub, start, stop)#返回sub第一次出现的下标，查不到报错
upper()#将字符串转为大写
1ower()#将字符串转为小写
格式化输出#
- format 语法 1：用数字占位（下标）
"{0} 嘿嘿".format("Python")
a = 100
s = "{0}{1}{2} 嘿嘿"
s2 = s.format(a, "JAVA", "C++")
print(s2)
2.format 语法 2：{} 占位
a = 100
s = "{}{}{} 嘿嘿"
s2 = s.format(a, "JAVA", "C++", "C# ")
print(s2)
#Output
100JAVAC++ 嘿嘿
3.format 语法 3：{} 占位用字母占位
s = "{a}{b}{c} 嘿嘿"
s2 = s.format(b="JAVA", a="C++", c="C# ")
print(s2)
#Output:
C++JAVAC# 嘿嘿
s.format (s2) 可理解为使用 s 格式化 s2
4.%s
语法为 “% s”%（值） ，最常用的参数可以是任意值。
例子：
for i in range(1, 10):
for j in range(1, i + 1):
print("%s * %s = %s" % (i, j, i * j), end="\t")
print()
#Output:
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
转义字符#
1. “\n” ：换行符
2. “\'”:单引号
3. “\“”:双引号
4. "\\" : \
在这里值得注意的是 \ ，它有很多比较巧的运用，比如可以实现代码换行
a = "sxsxsxsxsxsxsxs\
xsxsxsxs\
xsx"
print(a)
a = 1 + 2 + 3 \
+ 4
print(a)
#Output:
sxsxsxsxsxsxsxs xsxsxsxs xsx
10
字典（dict）#
字典是用来存储数据的，字典中的数据以映射关系存储。
字典的特点#
- 字典是 Python 中唯一的映射类型
2. 字典是无序的
3. 字典是可迭代对象
4. 字典的构成:
键：key
值：value
映射：键映射值
键 - 值：键值对，又叫 项
创建字典#
1. 直接创建
语法： d = {} #空字典
例如： d = {"name":"不良人","apple":"苹果"}
2. dict()
例如：d = dict() #空字典
3. dict(可迭代对象)
例子：
d3 = dict([("one",1),("two",2)])
print(d3)
#Output：
{'one': 1, 'two': 2}
这就是一个元组，one 是键，1 是值， ‘one’ : 1 是键值对。
4. dict(**kwargs)
例子：
d4 = dict(a=3, b=4)
print(d4)
#Output:
{'a': 3, 'b': 4}
字典访问#
- 基本形式：
变量名 [键名] #键所对应的值 - 添加一个键值对
变量名 [键名]= 值 - 修改一个键值对的值
变量名 [键名]= 值
Example
d = {"name": "小黑"}
print(d["name"])
#Output:
小黑