Python从入门到熟练

Python 环境

在Python官网下载的Python实际上是Python的解释器，而我们所熟知的PyCharm是一种Python的编辑器，Python安装教程已经非常丰富了，这里就不过多介绍

Python 语法与使用

基础语法

数据类型

在Python中有6种自带的数据类型

类型	描述
数字(Number)	整数(int)、浮点数(float)、复数(complex)、布尔值(bool)
字符串(String)	由一串字符组成的一种描述文本的数据类型
列表(List)	有序的序列
元组(Tuple)	有序的不可更改的序列
集合(Set)	无序不重复集合
字典(Dictionary)	键值对的集合

在Python中的数据类型我们可以使用type()函数查看，在Python中声明变量是不需要声明数据类型的，但是在使用过程中仍然要注意类型的匹配，在后面的学习中，我们会介绍标注类型的方法

Python是不受数据大小限制的，例如整数int是没有大小限制的

Python中值相同的变量指向的是同一个地址的，可以用id()来查看

注释

注释用法如下，举例

# 单行注释
"""
	多行注释1
	多行注释2
	多行注释3
"""

数据类型介绍

这里只做最最基础的介绍，之后讲到容器时会具体介绍

字符串

Python中有三种字符串定义方式

str1 = '字符串'
str2 = "字符串"
str3 = """字符串""" # 这里与多行注释不同的是有变量接收，同样也支持多行赋值
str4 = """
	字符串1
	字符串2
	字符串3
"""

列表

用方括号括起，内部元素可以是整数，字符串，其他容器

lt = [1,2,3]

元组

用圆括号括起，内部元素不可改变，可以是其他容器

tp = (1,2,3) # 多个元素声明
tp = (1,)    # 单个元素声明

集合

用花括号括起，内部元素可以改变但不能重复

st = {
   1,2,3} 

字典

由花括号括起，内部元素可以改变且无序，类似于生活中的字典

dic = {
   'key1' : 'val1','key2' : 'val2'}

类型转换

在不同的使用场景下需要不同的数据类型，因此就需要类型转换的功能，例如int()转换为整数，float()转换为浮点数，str()转换为字符串

标识符

我们给变量、类、函数起名时的标识符有如下限制

1. 标识符中可以出现英文、中文、数字、下划线，注意其中数字不可以作为开头使用
2. Python中的关键字不允许作为标识符使用

False True None and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield

注意其中的False、True、None的首字母需要大写

运算符

算数运算符

运算符	描述
+	加
-	减
*	乘
/	除
//	取整除
%	取模
**	指数

赋值运算符

运算符	描述
=	赋值

复合运算符

运算符	描述
+=	加法赋值
……	诸如此类

注意Python不支持++，–操作

字符串

字符串拼接

直接用加号即可拼接

例如

print("str1"+"str2")

name = 'your str'
print("str1"+name+"str2")

字符串格式化

一旦变量过多，要输出需要拼接许多次，略显麻烦，可以采用字符串格式化来表示

例如

mas1 = "str1"
mas2 = "mas1 = %s" % mas1

这里就使用%s进行占位，来进行变量的输出

需要注意的是，多个变量的时候需要在之后用圆括号括起，并按照顺序填写

例如

mas1 = "str1"
mas2 = "str2"
mas3 = "mas1 = %s, mas2 = %s" % (mas1,mas2)

关于其他占位符

占位符	说明
%s	字符串
%d	整数
%f	浮点数

关于浮点数的精度控制可以用 m.n 来控制

m控制宽度，要求是数字

.n，控制小数点精度，要求是数字

示例：

• %5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格][空格][空格]11，用三个空格补足宽度。
• %5.2f：表示将宽度控制为5，将小数点精度设置为2。小数点和小数部分也算入宽度计算。
  • 如，对11.345设置了%7.2f 后，结果是：[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .35
• %.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35

使用占位符进行格式化的效率比较慢，有第二种格式化的方法，会比较常用，例如

mas1 = "str1"
mas2 = "str2"
print(f"mas1 = {
     mas1}, mas2 = {
     mas2}")

需要注意的是，这种写法不用做精度控制，也不需要管类型是如何，适用于快速格式化，较为方便和易读，在花括号内填入变量名或者表达式都可以。

判断语句

bool 类型

bool 类型可以用True和False表示真或假，实际上的数值Ture是1，False是0

要注意这里的首字母需要大写

也可也通过比较运算符来获取结果，这个结果也是bool类型

语法

在Python种基本上不使用大括号进行代码块的区分，而是使用冒号加缩进的方式，因此Python对于格式的要求十分严格，例如

if 语句

condition = int(input()) # 这里利用input函数读取用户输入的数字，默认为字符串，利用int函数转换为整数

if condition > 20:
    print("condition is true!")

判断语句的结果必须是bool类型，仅当结果为True时会执行代码块内的语句

if else 语句

condition = int(input())

if condition > 20:
    print("condiiton is true!")
else:
    print("condition is false!")

else即为条件不成立时执行的语句

else之后不需要加条件，但和if一样需要加冒号

if elif else 语句

当判断条件不止一个时需要用elif实现，elif实际上是 else if 的缩写

condition = int(input())

if condition > 20:
    print("condiiton is true!")
elif condition > 10:
    print("condition is true, too!")
else:
    print("condition is false!")

循环语句

顾名思义，只要条件满足，语句会永远执行

while循环

condition = int(input())
i = 0;
while i < condition:
    print("condiiton is true!")

例如，利用循环求从1到100的和

i = 1
ans = 0
while 1 <= 100:
    ans += i
print(f"ans = {
     ans}")

for 循环

这里需要补充一些(转义字符)[http://t.csdnimg.cn/cVNjp]的知识，方便大家的学习

基础语法如下

for 临时变量 in 数据集:
    代码

这个句子的意思是从待处理数据集中：逐个取出数据赋值给临时变量

这里的数据集可以是一个范围range，等下我们会讲到，字符串、列表等，临时变量会依次取出其中的数据

range 语句

range实际上从英语意义上理解就可以知道他是范围的意思，他有如下几种用法

case 1

range(num)

从0开始依次取到num的前一个数字，这里的num为整数

case 2

range(num1, num2)

从num1开始取到num2的前一个数字，左闭右开区间

case 3

range(num1, num2, step)

从num1开始取到num2，step为步长，默认为1

同样的，我们可以用for循环求从1到100的和

ans = 0
for i in range(1,101)
	ans += i

作用域

在学习完分支循环等控制流程的语句之后，我们已经对代码块有了一个初步的理解

实际上变量也是有其生命周期的，也就是他的作用域，语句执行出这个代码块之后，他本身就不允许再被访问了

循环的中断

在循环的过程中我们会遇到很多意外的情况，需要跳出循环或者跳过这一层循环，这时候就需要break和continue关键字了

break

break是用于循环内部，当执行到break语句时，循环会直接结束

continue

当执行到continue时，会跳过这一次的循环

函数

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

他具有高复用性，方便了程序的编写与使用

定义语法

def 函数名(传入参数):
    函数体
    return 返回值

定义是这样的，调用就是直接写函数名称和你需要传入的参数即可

参数和返回值如果不需要是可以省略，需要注意的是函数必须要先定义好才能使用

传参

例如：

def add(x,y):
    res = x + y
    print(f"{
     x}+{
     y}={
     res}")

要注意传参需要用逗号进行分隔

返回值

是为了返回程序执行的结果

例如

def add(x,y):
    res = x + y
    return res

这里就是返回了结果

None类型

实际上没有调用return进行返回数据时，函数也是有返回值的，就是None，其实就是返回空的意思，当函数遇到了特殊情况需要结束函数时，即可调用return None进行返回

函数说明

当我们进行团队协作完成项目时，最好写上函数说明，用于辅助理解函数的作用，例如变量的含义，返回值的含义等

作用域

变量作用域指的是变量的作用范围，主要分为局部变量和全局变量

局部变量是定义在函数体内部的变量，即只在函数体内部生效，只在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

全局变量指的是在函数体内、外都能生效的变量

使用 global关键字 可以在函数内部声明变量为全局变量

数据容器

数据容器是一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等

在Python中有不同的数据容器，他们有不同的特性，分为五类：列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

list 列表

定义

list_name1 = [name1,name2,name3,...]
list_a = []
list_b = list()

以方括号作为表示，用逗号隔开，元素之间可以是不同的数据类型，支持嵌套，后面两种都是定义空列表的方式

例如

list_name2 = [[1,2,3],[3,4,5]]

使用

数组是利用下标索引进行访问的，有两种标号方式，一种是从左到右，依次标号为0，1，2，…；第二种是从右到左，一次标号为-1，-2，-3，…；

当我们想要进行取出数据时，可以利用方括号+下标的方式取出，例如

list_1 = list_name1[0]
list_2 = list_name2[0][1]

方法

这里的方法其实就类似于函数，但是需要配合数据容器进行使用

查找下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index(元素)

list_name3 = ['name1','name2','name3']
print(list_name3.index('name2'))  # 结果会输出 1

列表修改

功能：修改列表中元素的值

语法：列表[下标] = 值

list_name3[2] = 'name4'

插入

语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素

list_name3.insert(2,'name3')
print(list_name3) # 结果 ['name1','name2','name3','name4']

追加

语法：列表.append(元素)，将指定元素，追加到列表的尾部

list_name3.append('name5')

语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

list_name4 = ['name6','name7']
list_name3.append(list_name4)
print(list_name3) # 结果 ['name1','name2','name3','name4''name5','name6','name7']

删除

1. del 列表[下标]

   del list_name3[6]
   

2. 列表.pop(下标)

   list_name3.pop(5)
   

修改

1. 删除第一个匹配的元素 列表.remove(元素)

   list_name3.remove('name5')
   

2. 清空列表 列表.clear()

   list_name4.clear()
   

3. 统计某元素在列表内的数量 列表.count(元素)

   list_name3.count('name2')
   

查询

统计列表内，有多少元素

语法：len(列表)

可以得到一个int数字，表示列表内的元素数量

print(len(list_name3)) # 结果是 4

需要注意的是，方法其实非常多，也不需要死记硬背，用的多的自然会记下来，我们只需要知道有这样一个方法即可，要用的时候，只需要查一下

循环遍历

1. while

   index = 0
   while index < len(列表):
    元素 = 列表[index]
    处理
    idnex += 1
   

   这是列表一个简单的遍历，如果没有理解可以看一下之前流程控制的章节

2. for

   for 临时变量 in 容器
   	处理
   

   这里与上面不同的是，临时变量可以直接使用，类似于while循环中的元素，也相对便利，了解C++的朋友也可以认为这是简化版的范围for，这在我介绍C++的迭代器的部分也有提及，感兴趣的朋友可以选择性阅读

tuple 元组

列表是可修改的，元组是不可修改的，同样的，也可以包含不同类型的元素

定义

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

tuple1 = (e1,e2,e3,...)
tuple2 = ()
tuple3 = tuple()
tuple4 = (e1,)
tuple5 = (e1)

tuple2和tuple3都是空元组，tuple4是只含一个元素的元组，需要注意的是当元组只有一个数据时，这个数据之后需要添加逗号，否则就不是元组类型，而是他本身的类型

操作

元组由于不可修改的特性，所以其操作方法非常少

方法	说明
index()	查找元组内数据，存在则返回下标，不存在则报错
count()	统计某个元素在元组内出现的次数
len()	统计元组内元素的个数

其余的特性除了修改元组内容基本上都和列表一样

str 字符串

对于字符串来说，他只是字符的容器，因此同样也支持下标的访问，他的内容也无法进行修改，我们只能对旧字符串操作之后得到新的字符串，原来的字符串是无法修改的

方法

查找下标

语法：字符串.index(字符串)

str1 = "rick and morty"
print(str1.index("and")) # 结果是5

替换

语法：字符串.replace(字符串1，字符串2）

功能：将字符串内的全部：字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到了一个新字符串

str2 = str1.replace("and","or")
print(str2) # 结果是 rick or morty

分割

语法：字符串.split(分隔符字符串）

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

list1 = str1.split(' ')
print(list1) # 结果是 ['rick','and','morty']

去除前后空格

语法：字符串.strip()

str3 = "  rick and morty  "
str4 = str3.strip()

去除前后指定字符

语法：字符串.strip(字符串)

str5 = "_~rick and morty~_"
str6 = str5.strip("_~")

需要注意的是这里本质上是从传入的两个字符依次比较，删除相同的字符

统计字符串出现次数

语法：字符串.count(字符串)

count1 = str1.count('and')

统计字符串长度

语法：len(字符串)

len1 = len(str1)

序列的切片

序列

序列是指内容连续、有序，可以使用下标引用的一类数据容器，而列表、元组、字符串都是序列

序列的切片

这里切片的含义是从一个序列中取出一个子序列

语法：序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

步长表示，依次取元素的间隔

步长1表示，一个个取元素

步长2表示，每次跳过1个元素取

步长N表示，每次跳过N-1个元素取

步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意：此操作不会影响序列本身，而是会得到一个新的序列

例如

list1 = [1,2,3,4,5]
list2 = list1[1:4] # 从下标1开始取到4结束，前闭后开

这个操作对列表、元组、字符串是通用的

同时非常灵活，根据需求，起始位置，结束位置，步长（正反序）都是可以自行控制的

set 集合

集合的概念类似于数学上集合的定义，具有不重复，无序的特点

那我们其实可以利用这个特点做去重的工作

定义

set1 = {
   e1,e2,...}
set2 = set()

在定义集合时哪怕e1和e2相同，他也会自动帮你去重

方法

因为集合是无序的，所以集合不支持下标索引访问

添加

语法：集合.add(元素)。将指定元素，添加到集合内

set1 = {
   'e1','e2'}
set1.add('e3')

移除

语法：集合.remove(元素)，将指定元素，从集合内移除

set1.remove('e2')

随机取出

语法：集合.pop()，功能，从集合中随机取出一个元素

elemment = set1.pop()

需要注意的是这个操作之后，集合本身也会被修改，元素被移除

清空

语法：集合.clear()，功能，清空集合

set1.clear()

差集

语法：集合1.difference(集合2)

set3 = set2.difference(set1)

结果是得到一个新集合，集合1和集合2不变

消除差集

语法：集合1.difference_update(集合2)

set1.difference_update(set2)

简单说就是在set1中消除set2中也有的元素

并集

语法：集合1.union(集合2)

set3 = set1.union(set2)

结果会得到新集合，集合1和集合2不变

其余的len()和遍历与其他容器相同

dict 字典

字典实际上就是类似于生活中的字典，是由键值对组成，键是指key，关键字的意思，值是值value

定义

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对

例如

dict1 = {
   key:val,key:val,...}
dict2 = dict()
dict3 = {
   }

1. key和value可以是任意类型的数据（key不可为字典）

2. key不可重复，重复会对原有数据覆盖

访问

字典同样是无序的，无法用下标访问，但是可以利用key来访问

例如

dict1 = {
   'Summer':17,'Morty':14,'Rick':60}
print(dict1['Morty'])