学完Python，我决定熬夜整理这篇总结...

旧城等待， 2023-03-06 03:21 31阅读 0赞

> 前言：学习Python，我决定熬夜整理这篇总结…

![桌面][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9tYV8yMDE4_size_16_color_FFFFFF_t_70_pic_center]

### 目录 ###

*  了解Python
 *  Python基础语法
 *  Python数据结构
 *   *  数值
     *  字符串
     *  列表
     *  元组
     *  字典
     *  集合
 *  Python控制流
 *   *  if 判断语句
     *  for 循环语句
     *  while 循环语句
     *  break 和 continue
 *  Python函数
 *   *  自定义函数 def
     *  匿名函数 lambda
 *  Python对象
 *  Python 文件读写
 *  Python 异常捕获
 *  Python 常用工具库
 *   *  标准库
     *  第三方库
 *  爬虫实践

# 了解Python #

*  Python之父 Guido Van Rossum，一位荷兰程序员，在1989年圣诞节编写了Pyhon语言。
 *  1991年第一个Python解释器诞生，由C语言编写
 *  2000年Python2.0诞生
 *  2008年Python3.0诞生
 *  2020年Python2.0停止维护，Python3.0更加简洁
 *  Python是一门高级面向对象的编程语言，是动态解释性语言，拥有优雅的结构和清晰的语法，简单易学。提供了丰富的第三方库。Python也可以调用其他语言的代码，又称为胶水语言。
 *  Python的使用领域非常多，人工智能、数据科学、编写系统工具、APP、自动化脚本、WEB开发等…

# Python基础语法 #

*  **注释**

1.  使用 \# 注释内容 号实现单行注释
2.  使用 “”" 注释内容 “”" 三引号实现多行注释

*  **导入库**

1.  导入模块  import os
2.  导入模块中的对象  from os import getcwd
3.  导入模块并起个别名  import pandas as pd

*  **变量使用**

1.  Python中变量名（标识符）由字母数字下划线组成，并且不能以数字开头，不能和关键字重名
2.  查看Python中的关键字  keyword.kwlist  或者  help(“keywords”) 
3.  Python中变量根据作用域范围分为全局变量（整个模块内使用）和局部变量（在定义的方法和函数内使用）

*  **执行顺序**  
    Python语句自上而下执行
 *  **缩进格式**  
    Python使用缩进区分代码块，缩进可以是 n >=1，全局要保持一致
 *  **基础函数**

<table> 
 <thead> 
  <tr> 
   <th align="left">函数名</th> 
   <th align="left">函数功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><font>help() </font></td> 
   <td align="left">查看帮助信息，help(print)</td> 
  </tr> 
  <tr> 
   <td align="left"><font>dir() </font></td> 
   <td align="left">查看函数的属性和具有的方法，dir(print)</td> 
  </tr> 
  <tr> 
   <td align="left"><font>id() </font></td> 
   <td align="left">查看标识符的内存地址，a = 1 print(id(a))</td> 
  </tr> 
  <tr> 
   <td align="left"><font>type() </font></td> 
   <td align="left">查看数据类型</td> 
  </tr> 
  <tr> 
   <td align="left"><font>del() </font></td> 
   <td align="left">删除对象</td> 
  </tr> 
  <tr> 
   <td align="left"><font>input() </font></td> 
   <td align="left">接受输入，输入类型为字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><font>len() </font></td> 
   <td align="left">查看对象长度</td> 
  </tr> 
 </tbody> 
</table>

# Python数据结构 #

> Python中内置的数据结构有六种：**Number（数值）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）、Set（集合）**。除此之外还有数组、矩阵等结构需要导入工具包才能使用。

## 数值 ##

Python3 里支持 int、float、bool、complex（复数）几种类型的数值

*  print(a / b) : 得到 a 除 b 的浮点数值
 *  print(a // b) : 得到 a 除 b 的整数值
 *  print(a \*\* b) : 得到 a 的 b 次方数值

## 字符串 ##

Python中字符串是由一个或多个字符组成的序列，字符个数即为字符串长度。注意Python中没有字符类型，单个字符被认作长度为1的字符串。

*  创建字符串：使用单引号或者双引号创建的字符串完全一样，三引号字符串可以是多行字符串，如下图  
    ![图2][2]
 *  转义字符：使用单引号或者双引号创建多行字符串时可以使用转义字符 \\n 实现，还可以使用 \\ 屏蔽特殊符号功能
 *  原始字符串：在字符串前面加 r，打印最原始字符串，S = r"P\\y\\thon"
 *  访问字符串元素：通过下标访问，字符串是一个有序且不可变的结构
 *  字符串加法和乘法：加法用于拼接，乘法用于重复
 *  字符串切割操作：str.split(str1) 以str1为分隔符对字符串切割
 *  字符串替换操作：str.replace(str1, str2) 将字符串中的 str1 替换成 str2 生成新的字符串
 *  字符串大小写转换：str.lower() 将字符串中的大写字符转换成小写， str.upper() 将字符串中的小写字符转换成大写
 *  字符串拼接：str.join(iter) 将所给参数 iter 中的每个元素以指定的字符串 str 连接生成一个新的字符串  
    ![图3][3]
 *  格式化输出：使用格式化操作符 % 辅助实现格式化输出，如 print(“My name is %s, age is %d.” %(‘Python’, 31))

## 列表 ##

列表是一个序列，其中的元素可以是任意的数据类型，并且可以随时地添加或删除元素。

List = [1, 2, 3]      #创建列表
    List[1]               #访问元素
    List[1] = 0           #修改元素
    print(List)           #打印 [1, 0, 3]

*  列表运算符  
    列表中的运算符和字符串中的相同，如下代码

a = [1, 2, 3]
    b = [4, 5]
    print(a * 2)          #打印 [1, 2, 3, 1, 2, 3]
    print(a + b)          #打印 [1, 2, 3, 4, 5]

*  列表数据操作

<table> 
 <thead> 
  <tr> 
   <th align="left">类成员函数</th> 
   <th align="left">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><font>list.append(obj)</font></td> 
   <td align="left">在列表末尾添加新的对象</td> 
  </tr> 
  <tr> 
   <td align="left">l<font>ist.remove(obj)</font></td> 
   <td align="left">移除列表中的某一个值的第一个匹配项</td> 
  </tr> 
  <tr> 
   <td align="left"><font>list.insert(index, obj)</font></td> 
   <td align="left">将指定对象 obj 插入指定位置 index</td> 
  </tr> 
  <tr> 
   <td align="left"><font>list.pop([index = -1])</font></td> 
   <td align="left">移除列表中对应下标位置的元素，默认是最后一个位置</td> 
  </tr> 
  <tr> 
   <td align="left"><font>list.reverse()</font></td> 
   <td align="left">逆置列表中的元素</td> 
  </tr> 
  <tr> 
   <td align="left"><font>list.sort(cmp=None, key=None, reverse=False)</font></td> 
   <td align="left">cmp为可选参数，如果指定了该参数，会使用该参数的方法进行排序。key是用来进行比较的元素。reverse=False 为升序</td> 
  </tr> 
  <tr> 
   <td align="left"><font>enumerate(list)</font></td> 
   <td align="left">遍历并获取元素和对应索引，一般用于for循环中</td> 
  </tr> 
  <tr> 
   <td align="left"><font>squares = [x*2 for x in list]</font></td> 
   <td align="left">列表推导式，批量生成符合规则的元素组成的列表</td> 
  </tr> 
 </tbody> 
</table>

# 遍历并获取元素和对应索引
    animals = ['dog', 'cat', 'fish']
    for i in enumerate(animals):
        print(i)

> (0, ‘dog’)  
> (1, ‘cat’)  
> (2, ‘fish’)

# 列表推导式
    squares = [x*2 for x in animals]
    print(squares)

> \[‘dogdog’, ‘catcat’, ‘fishfish’\]

*  列表索引与切片  
    **索引**的访问从 0 到 n-1，所有有序序列都能使用  
    **切片**List\[start : end : step\]，start 为 0 时可以省略，end 为 n-1 时可以省略，step 为1时以省略，注意： step 取负值时，反向取值

## 元组 ##

元组是一个不可变的有序序列，类似于字符串，但不同的是，元组中的对象可以是任意对象。

Tuple = (1, ['a', 'b'], "Python")        #创建元组
    print(Tuple)                             #打印 (1, ['a', 'b'], 'Python')
    print(type(Tuple))                       #打印 <class 'tuple'>

*  创建单个元组需要使用 “,” 来标明是元组
 *  元组不可变，修改数据会报错，不推荐变相修改元组数据

t1 = (1)
    t2 = (1,)
    print("t1 type: ", type(t1), "\n" "t2 type: ", type(t2))

> t1 type: <class ‘int’>  
> t2 type: <class ‘tuple’>

## 字典 ##

Python中字典的每个元素由一组键-值对组成，其中键是唯一不可变的，如果字典有相同的键，则后面的值会覆盖前面的值。当数据量大时，字典的访问速度比列表快。

*  字典的定义

# 字典的三种赋值操作
    x1 = {
        'name':'Caso', 'age':18, 'sex':'man'}
    x2 = dict(name = 'Caso', age = 18, sex = 'man')
    x3 = dict([("name", "Caso"), ("age", 18), ("sex", "man")])
    print(x1)
    print(x2)
    print(x3)

> \{‘name’: ‘Caso’, ‘age’: 18, ‘sex’: ‘man’\}  
> \{‘name’: ‘Caso’, ‘age’: 18, ‘sex’: ‘man’\}  
> \{‘name’: ‘Caso’, ‘age’: 18, ‘sex’: ‘man’\}

*  获取字典数据

# 1.直接使用键获取值，输入不存在的键会报错
    print(x1['name'])
    # 2.使用 get(key, ["str"]) 方法获取数据
    print(x1.get("age"))
    # 2.1 使用 get 获取值时，键值不存在会返回 None 或指定的值
    print(x1.get("school"))
    print(x1.get("school", "school not exist"))
    # 3.查看所有的键
    print(x1.keys())
    # 4.查看所有的值
    print(x1.values())
    # 5.查看所有的键值对
    print(x1.items())

以上代码输出如下：

> Caso  
> 18  
> None  
> school not exist  
> dict\_keys(\[‘name’, ‘age’, ‘sex’\])  
> dict\_values(\[‘Caso’, 18, ‘man’\])  
> dict\_items(\[(‘name’, ‘Caso’), (‘age’, 18), (‘sex’, ‘man’)\])

*  向字典插入数据

x1["school"] = "爱丁堡"
    print(x1)

> \{‘name’: ‘Caso’, ‘age’: 18, ‘sex’: ‘man’, ‘school’: ‘爱丁堡’\}

*  修改字典中数据

x1["age"] = 25
    print(x1)

> \{‘name’: ‘Caso’, ‘age’: 25, ‘sex’: ‘man’, ‘school’: ‘爱丁堡’\}

## 集合 ##

Python集合中的元素是唯一的，重复的元素会被删除。

*  定义集合

keyset = {
        'name', 'age', 'sex', 'school'}
    # 使用 in 检查某一元素是否存在
    print("score" in keyset)

> False

*  添加元素

# set.add(obj) 给集合添加元素，如果该元素已存在，则不执行任何操作
    keyset.add('name')
    keyset.add('score')
    print(keyset)

> \{‘score’, ‘name’, ‘school’, ‘sex’, ‘age’\}

*  删除元素

# set.remove(obj) 移除集合中的指定元素
    keyset.remove('name')
    print(keyset)

> \{‘score’, ‘school’, ‘sex’, ‘age’\}

*  集合唯一性

Test = [1, 2, 3, 2, 3, 5]
    # 利用集合的唯一性给列表去重
    print(list(set(Test)))

> \[1, 2, 3, 5\]

# Python控制流 #

Python中的控制流关键字 if、elif、else、for、while、break、continue.

## if 判断语句 ##

Python中的条件控制通过判断条件语句的执行结果是（True or False）来决定所执行的代码块；有多个代码块可以用 if - elif - else，如下：

# 是不是狗？
    game = input("请输入: ")
    if game == 'Dog':
        print("Oh, you're True Dog!")
    elif game == 'not Dog':
        print("hh, you're not Dog! Congratulation!")
    else:
        print("Ok, you are man?")

![dog][]  
需要注意一点，在Python中 0、None、空值均默认为False，其他都为True

## for 循环语句 ##

Python中for循环不同于其他语言for循环一点就是，它能接受可迭代对象（如序列）作为其参数，每次迭代其中一个参数。  
for循环后面还可以加else，在循环结束后正常执行。

for i in ['you', 'are', 'true', 'dog']:
        print(i)
    else:
        print("算了，不和狗计较！")

> you  
> are  
> true  
> dog  
> 算了，不和狗计较！

Python中的嵌套循环，eg：输出乘法口诀表

for i in range(1, 10):
        for j in range(1, i+1):
            print("%dX%d=%-2d"%(j, i, j*i), end=" ")
        print()

> 1X1=1  
> 1X2=2 2X2=4  
> 1X3=3 2X3=6 3X3=9  
> 1X4=4 2X4=8 3X4=12 4X4=16  
> 1X5=5 2X5=10 3X5=15 4X5=20 5X5=25  
> 1X6=6 2X6=12 3X6=18 4X6=24 5X6=30 6X6=36  
> 1X7=7 2X7=14 3X7=21 4X7=28 5X7=35 6X7=42 7X7=49  
> 1X8=8 2X8=16 3X8=24 4X8=32 5X8=40 6X8=48 7X8=56 8X8=64  
> 1X9=9 2X9=18 3X9=27 4X9=36 5X9=45 6X9=54 7X9=63 8X9=72 9X9=81

## while 循环语句 ##

Python中的while语句，在循环条件成立下，执行循环体，也可以加else语句。  
Python中没有 do-while 语句。

game = ['life', 'is', 'True']
    i = 0
    while i < 3:
        print(game[i])
        i += 1
    else:
        print("未完待续...")

> life  
> is  
> True  
> 未完待续…

## break 和 continue ##

Python中使用break跳出当前循环，使用continue跳过当次循环

while True:
        game = input("请承认自己很狗!\n")
        if game == "你是真的狗":
            print("好吧，确实狗！")
            break;
        else:
            print("不承认是吧？直到你承认！")
            continue
        print("反正你到不了这里！") # 要么break，要么continue

![gou][]

# Python函数 #

## 自定义函数 def ##

自定义一个函数，返回一个序列，使得序列中每个数字都是前两个数字之和（斐波那契数列）

def fibs(nums):
        result = [0, 1];
        for i in range(2, nums):
            val = result[i-1] + result[i-2]
            result.append(val)
        return result
    print(fibs(5))

> \[0, 1, 1, 2, 3\]

Python函数中的几种传参方式：

<table> 
 <thead> 
  <tr> 
   <th align="left">参数类型</th> 
   <th align="left">传入方式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">必备参数</td> 
   <td align="left">必须以正确的顺序传入函数，调用时的数量必须和声明时的一样</td> 
  </tr> 
  <tr> 
   <td align="left">关键字参数</td> 
   <td align="left">函数调用时以等号赋值的形式传入</td> 
  </tr> 
  <tr> 
   <td align="left">默认参数</td> 
   <td align="left">调用函数时，缺省参数值如果没有传入，则被认为是默认值</td> 
  </tr> 
  <tr> 
   <td align="left">不定长参数</td> 
   <td align="left">声明时不会命名。如 args、**kwargs，加 * 号的args是元组，加**号的kwargs存放命名参数，形如key=value的参数，kwargs为字典</td> 
  </tr> 
 </tbody> 
</table>

def func(a=1, b=2, *args):
        print(a, b)
        print(args)
    # 1. 传必备参数
    func(0, 4)
    # 2. 传关键字参数
    func(b=4, a=0)
    # 3. 传默认参数
    func()
    # 4. 传不定长参数
    func(1, 2, 3, 4, 5)

> 0 4  
> ()  
> 0 4  
> ()  
> 1 2  
> ()  
> 1 2  
> (3, 4, 5)

## 匿名函数 lambda ##

Python中lambda用来创建匿名函数，相比于普通函数，匿名函数只是一个表达式，函数体比def简单，只能封装有限的逻辑。

max = lambda x,y : x + y
    max(2, 3)

> 5

# Python对象 #

Python中创建类使用关键字class，并且具备封装、多态和继承的特点。

class Person(object):
        def __init__(self, age, name): # self指实例化的对象
            self.__age = age;
            self.name = name
        def show(self):
            print("My name is %s"%(self.name))
            print("age: %d"%(self.__age))
    # 实例化对象
    p1 = Person(age=18, name="dog")
    p1.show() 
    # Python的继承
    class Man(Person):
        pass
    # 子类实例化
    man = Man(age=25, name="Caso")
    man.show()

> My name is dog  
> age: 18  
> My name is Caso  
> age: 25

默认情况下，属性在Python中都是 public 公有的，该类所在的模块或其他导入了该类的模块都可以访问到。如果想要类中某些属性不想被外界访问或继承可对其私有化。

*  在属性或方法前加一个下划线\_，可防止该属性被导入到其他模块使用，只在当前模块使用
 *  在属性或方法前加两个下划线\_\_，实现完全私有化，类外不能访问

# Python 文件读写 #

Python中内置了读写文件的函数：open，返回文件对象。  
通常用法：open(filename, mode, encoding)

<table> 
 <thead> 
  <tr> 
   <th align="left">参数值</th> 
   <th align="left">参数说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">filename</td> 
   <td align="left">传入要访问的文件名称的字符串值</td> 
  </tr> 
  <tr> 
   <td align="left">mode</td> 
   <td align="left">设定打开文件的模式（r：只读、w：写入、a：追加、*b：二进制的形式）</td> 
  </tr> 
  <tr> 
   <td align="left">encoding</td> 
   <td align="left">打开文件的编码格式，默认为 utf-8</td> 
  </tr> 
 </tbody> 
</table>

f = open("text.txt", 'w') # 打开文件text.txt，当文件不存在时会新建一个
    str = input("输入要写入的内容: ")
    f.write(str) # 将str内容写入文件
    f.close() # 关闭该文件描述符

> E:>type text.txt  
> Caso\_卡索

f = open("text.txt", 'r')
    print(f.read(6)) # 读取6个字符，并将光标后移6个字符
    print(f.read()) # 读取光标所在位置至最后
    f.close()

> Caso\_卡  
> 索

# 使用with语句进行文件写入
    with open("test.txt", 'w') as f:
        f.write("使用with语句进行文件写/读")
    # 使用with语句读取文件内容
    with open("test.txt", 'r') as f:
        print(f.read())

> 使用with语句进行文件写/读

# Python 异常捕获 #

程序异常，一般指运行时出现错误（比如被除数为零、列表下标越界、修改字符串等），Python中用于处理异常的关键字有 try、except、final 等。

# 使用 try、except、final 示例程序异常捕获
    try:
        print(1/0)
    except Exception as e: # Exception 常规错误的基类
        print(e)
    finally:  # 退出try时总会执行
        print("最后都会执行finally中的语句")

> division by zero  
> 最后都会执行finally中的语句

# Python 常用工具库 #

关于这部分内容准备另写博客进行总结，分为常用标准库一篇，第三方库根据具体库的使用再做总结，最后汇总一篇链接出来。

## 标准库 ##

Python自带的一些库，如：os、sys、time等模块，打算另写一篇博客总结。  
[Python标准库之——time模块][Python_time]  
[Python标准库之——os模块][Python_os]

## 第三方库 ##

需要自行安装的第三方库。如numpy（科学计算）、pandas（数据处理）等三方库

# 爬虫实践 #

[Python爬虫分析CSDN个人博客数据][Python_CSDN]

--------------------

> 作者： Caso\_卡索  
> 博客: https://blog.csdn.net/xiaoma\_2018  
> 版权声明：未经允许不得转载本文
> 
> 喜欢的朋友点赞支持一下，在此感谢

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9tYV8yMDE4_size_16_color_FFFFFF_t_70_pic_center]: /images/20230208/7a1eac3116ad4f3b95bbe26f9b41f09f.png
[2]: /images/20230208/9663f193513c46df82d1c33051a7dacc.png
[3]: /images/20230208/a09f5c7ef97244b5a5e67f2f36a2f597.png
[dog]: /images/20230208/0b4c24b63bb74c63aa3c56d9125e89f3.png
[gou]: /images/20230208/e09941935c3841ed85f28a9608d22477.png
[Python_time]: https://blog.csdn.net/xiaoma_2018/article/details/108165349
[Python_os]: https://blog.csdn.net/xiaoma_2018/article/details/108189852
[Python_CSDN]: https://blog.csdn.net/xiaoma_2018/article/details/108231658