学完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,全局要保持一致
  • 基础函数

函数名

函数功能

help()

查看帮助信息,help(print)

dir()

查看函数的属性和具有的方法,dir(print)

id()

查看标识符的内存地址,a = 1 print(id(a))

type()

查看数据类型

del()

删除对象

input()

接受输入,输入类型为字符串

len()

查看对象长度

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的字符串。

  • 创建字符串:使用单引号或者双引号创建的字符串完全一样,三引号字符串可以是多行字符串,如下图

  • 转义字符:使用单引号或者双引号创建多行字符串时可以使用转义字符

    实现,还可以使用 屏蔽特殊符号功能

  • 原始字符串:在字符串前面加 r,打印最原始字符串,S = r"Py hon"

  • 访问字符串元素:通过下标访问,字符串是一个有序且不可变的结构
  • 字符串加法和乘法:加法用于拼接,乘法用于重复
  • 字符串切割操作:str.split(str1) 以str1为分隔符对字符串切割
  • 字符串替换操作:str.replace(str1, str2) 将字符串中的 str1 替换成 str2 生成新的字符串
  • 字符串大小写转换:str.lower() 将字符串中的大写字符转换成小写, str.upper() 将字符串中的小写字符转换成大写
  • 字符串拼接:str.join(iter) 将所给参数 iter 中的每个元素以指定的字符串 str 连接生成一个新的字符串

  • 格式化输出:使用格式化操作符 % 辅助实现格式化输出,如 print(“My name is %s, age is %d.” %(‘Python’, 31))

列表

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

List = [1, 2, 3]      #创建列表

List[1] #访问元素

List[1] = 0 #修改元素

print(List) #打印 [1, 0, 3]

  • 1
  • 2
  • 3
  • 4

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

a = [1, 2, 3]

b = [4, 5]

print(a * 2) #打印 [1, 2, 3, 1, 2, 3]

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

  • 1
  • 2
  • 3
  • 4

  • 列表数据操作

类成员函数

功能

list.append(obj)

在列表末尾添加新的对象

list.remove(obj)

移除列表中的某一个值的第一个匹配项

list.insert(index, obj)

将指定对象 obj 插入指定位置 index

list.pop([index = -1])

移除列表中对应下标位置的元素,默认是最后一个位置

list.reverse()

逆置列表中的元素

list.sort(cmp=None, key=None, reverse=False)

cmp为可选参数,如果指定了该参数,会使用该参数的方法进行排序。key是用来进行比较的元素。reverse=False 为升序

enumerate(list)

遍历并获取元素和对应索引,一般用于for循环中

squares = [x*2 for x in list]

列表推导式,批量生成符合规则的元素组成的列表

# 遍历并获取元素和对应索引

animals = ["dog", "cat", "fish"]

for i in enumerate(animals):

print(i)

  • 1
  • 2
  • 3
  • 4

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

# 列表推导式

squares = [x*2 for x in animals]

print(squares)

  • 1
  • 2
  • 3

[‘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">

  • 1
  • 2
  • 3

  • 创建单个元组需要使用 “,” 来标明是元组

  • 元组不可变,修改数据会报错,不推荐变相修改元组数据

t1 = (1)

t2 = (1,)

print("t1 type: ", type(t1), "

" "t2 type: ", type(t2))

  • 1
  • 2
  • 3

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)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

{‘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())

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

以上代码输出如下:

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)

  • 1
  • 2

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

  • 修改字典中数据
  • 本文首发于python黑洞网,博客园同步更新

x1["age"] = 25

print(x1)

  • 1
  • 2

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

集合

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

  • 定义集合

keyset = {"name", "age", "sex", "school"}

# 使用 in 检查某一元素是否存在

print("score" in keyset)

  • 1
  • 2
  • 3

False

  • 添加元素

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

keyset.add("name")

keyset.add("score")

print(keyset)

  • 1
  • 2
  • 3
  • 4

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

  • 删除元素

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

keyset.remove("name")

print(keyset)

  • 1
  • 2
  • 3

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

  • 集合唯一性

Test = [1, 2, 3, 2, 3, 5]

# 利用集合的唯一性给列表去重

print(list(set(Test)))

  • 1
  • 2
  • 3

[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?")

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8


需要注意一点,在Python中 0、None、空值均默认为False,其他都为True

for 循环语句

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

for i in ["you", "are", "true", "dog"]:

print(i)

else:

print("算了,不和狗计较!")

  • 1
  • 2
  • 3
  • 4

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()

  • 1
  • 2
  • 3
  • 4

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("未完待续...")

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

life
is
True
未完待续…

break 和 continue

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

while True:

game = input("请承认自己很狗!

")

if game == "你是真的狗":

print("好吧,确实狗!")

break;

else:

print("不承认是吧?直到你承认!")

continue

print("反正你到不了这里!") # 要么break,要么continue

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

Python函数

本文首发于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))

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

[0, 1, 1, 2, 3]

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

参数类型

传入方式

必备参数

必须以正确的顺序传入函数,调用时的数量必须和声明时的一样

关键字参数

函数调用时以等号赋值的形式传入

默认参数

调用函数时,缺省参数值如果没有传入,则被认为是默认值

不定长参数

声明时不会命名。如 args、**kwargs,加 * 号的args是元组,加**号的kwargs存放命名参数,形如key=value的参数,kwargs为字典

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)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

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

匿名函数 lambda

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

max = lambda x,y : x + y

max(2, 3)

  • 1
  • 2

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()

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

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

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

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

Python 文件读写

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

参数值

参数说明

filename

传入要访问的文件名称的字符串值

mode

设定打开文件的模式(r:只读、w:写入、a:追加、*b:二进制的形式)

encoding

打开文件的编码格式,默认为 utf-8

f = open("text.txt", "w") # 打开文件text.txt,当文件不存在时会新建一个

str = input("输入要写入的内容: ")

f.write(str) # 将str内容写入文件

f.close() # 关闭该文件描述符

  • 1
  • 2
  • 3
  • 4

E:>type text.txt
Caso_卡索

f = open("text.txt", "r")

print(f.read(6)) # 读取6个字符,并将光标后移6个字符

print(f.read()) # 读取光标所在位置至最后

f.close()

  • 1
  • 2
  • 3
  • 4

Caso_卡

# 使用with语句进行文件写入

with open("test.txt", "w") as f:

f.write("使用with语句进行文件写/读")

# 使用with语句读取文件内容

with open("test.txt", "r") as f:

print(f.read())

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

Python 异常捕获

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

# 使用 try、except、final 示例程序异常捕获

try:

print(1/0)

except Exception as e: # Exception 常规错误的基类

print(e)

finally: # 退出try时总会执行

print("最后都会执行finally中的语句")

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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

Python 常用工具库

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

标准库

Python自带的一些库,如:os、sys、time等模块,打算另写一篇博客总结。
Python标准库之——time模块
Python标准库之——os模块

第三方库

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

爬虫实践
本文首发于python黑洞网,博客园同步更新

以上是 学完Python,我决定熬夜整理这篇总结... 的全部内容, 来源链接: utcz.com/z/530384.html

回到顶部