Python基础笔记(1)-Python速览

类型操作

python3中有六个标准数据类型，分别是Number数字、String字符串、List列表、Tuple元组、Set集合、Dictionary字典。数据类型有可变与不可变之分：

  • 不可变数据：Number、String、Tuple
  • 可变数据：List、Dictionary、Set

在参数传递过程中，不可变类型和可变类型有一定的区别：

  • 如果传递的是不可变类型，则是一个值传递，函数内部的修改不会对实际对象产生影响
  • 如果是可变类型，则是引用传递，函数内部的修改会对实际对象产生影响

数字(Number)

python3中的数字类型支持int、float、bool、complex（复数）。

可以使用type()内置函数来查询变量所指的对象类型，或者使用isinstance()来判断是否是某种类型：

1
2
3
a = 20
type(a) #  <class 'int'>
isinstance(a, int) # True
  • type()：只考虑最基本的类型，不会认为子类是一种父类类型
  • isinstance()：考虑继承，认为子类是一种父类类型

在变量赋值的时候创建Number对象，可以使用del语句删除单个或者多个对象的引用。

相关数学函数
abs(x) ceil(x) exp(x)
fabs(x) floor(x) log(x)
log10(x) max(x1,x2,...) min(x1,x2,...)
modf(x) pow(x, y) round(x [,n])
sqrt(x)
  • fabs(x)：返回数字的绝对值
  • modf(x)：返回x的整数部分与小数部分

字符串(String)

  • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义
  • 按字面意义级联字符串，如 "this " "is " "string"会被自动转换为 this is string
  • 字符串可以用 +运算符连接在一起，用 * 运算符重复。
  • Python 中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
  • 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
  • python字符串不能被改变，不能向一个索引位置赋值

字符串格式化：

1
2
3
4
5
6
7
8
9
10
# 1.使用%
"name: %s and age: %d"% ("haha", 10)

# 2.使用fomat
"{name}---{url}".format(name="hahaha", url="hahaha.com")

# 3.f-string
name = "haha"
f"Hello {name}" # 变量替换
f"{1+2}" # 表达式计算

字符串常用方法：

方法 描述
capitalize() 字符串首字母大写
swapcase() 大写转小写、小写zhuan
count(str, beg=0, end=len(string)) 返回str在字符串里面出现的次数
startswith(substr, beg=0, end=len(string)) 检查字符串是否以substr开始，返回布尔值
endswith(suffix, beg=0, end=len(string)) 检查字符串是否以suffix结束，返回布尔值
find(str, beg=0, end=len(string)) 检查str是否包含在字符串中，如果找到则返回开始索引，否则返回-1
rfind(str, beg=0, end=len(string)) 与find类似，不过是从右边开始查找
index(str, beg=0, end=len(string)) 与find类似，但是如果没有找到会报异常
rindex(str, beg=0, end=len(string)) 与index类似，不过是从右边开始查找
join(seq) 以字符串作为分隔符，对seq进行拼接
len(string) 返回字符串长度
replace(old, new [,max]) 将字符串中的old替换为new，max指定替换的最大次数
split(str="", num=string.count(str)) 以str为分隔符截取字符串，如果num有指定值，则仅截取num+1个子字符串
lstrip() / rstrip() / strip() 删除字符串左边/右边/左右的空格

列表(List)

增删改查：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
list = ["haha", 1, True]
# 增
list.append(456)

# 删
del list[1]

# 改
list[1] = 23

# 查
list[0]

# + 号用于组合列表，* 号用于重复列表

列表常用方法：

方法 描述
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值
list.index(obj) 从列表中找到某个值第一次匹配的索引位置
list.insert(index, obj) 将对象插入列表
list.pop([index = -1]) 移除列表中的元素并返回该值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 列表逆序
list.sort(key=None, reverse=False) 列表排序
list.clear() 清空列表
list.copy() 复制列表

元组(Tuple)

  • 可以使用下标索引来访问元组中的值，也可以截取其中的部分元素
  • 元组中的元素值不允许修改，但是可以对元组进行连接组合
  • 元组中的元素值不允许删除，但是可以用del语句删除整个元组

集合(Set)

  • 空集合的创建只能使用set()，因为{}是用来创建空字典的

集合常用方法：

方法 描述
add() 为集合添加元素
update() 为集合添加元素
clear() 移除集合中的所有元素
copy() 复制集合
union() 返回两个集合的并集
difference() 返回集合的差集
intersection() 返回集合的交集
symmetric_difference() 返回两个集合中不重复元素集合
isdisjoint() 判断两个集合是否包含相同元素
issubset() 判断集合是否为另一个集合的子集
issuperset() 判断集合是否为另一个集合的超集
pop() 随机移除元素
remove() 移除指定元素
discard() 删除集合中指定元素

字典(Dictionary)

  • 键值对中的Key必须是不可变类型，例如数字、字符串、元组

字典常用方法：

方法 描述
dict.clear() 删除字典内所有元素
dict.copy() 返回一个字典的浅复制
dict.fromkeys(seq[, value]) 静态方法。创建一个新字典，以序列seq中的值为key，value为默认值
dict.get(key, default=None) 返回指定Key的值，如果不在则返回默认值
dict.setdefault(key, default=None) 返回指定Key的值，如果不在则会添加对应的Key并将值设置为default
dict.items() 返回Key-Value集合
dict.keys() 返回Key集合
dict.values() 返回value集合
dict.update(dict2) 利用dict2来更新dict
dict.pop(key[,default]) 删除Key所对应的值并返回
dict.popitem() 返回并删除字典中的最后一个键值对

数据类型转换

函数 描述
int(x [,base]) 将x转换为一个整数，可以指定base进制
float(x) 将x转换为一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将x转换为字符串
repr(x) 将x转化为表达式字符串，返回一个对象的String格式
eval(str) 执行字符串中的有效Python表达式并返回一个对象
tuple(s) 将序列s转换为一个元组
list(s) 将序列s转换为一个列表
set(s) 将序列s转换为可变集合
dict(d) 创建一个字典，d是键值对元组序列
frozenset(s) 将s转换为不可变集合
chr(x) 将整数转换为一个字符，对应ASCII码
ord(x) 将字符转换为对应的ASCII码整数
hex(x) 将一个整数转换为十六进制字符串
oct(x) 将一个整数转换为八进制字符串

模块和包

模块是一个包含所有定义函数和变量的文件，其后缀名为.py。模块可以被其他的程序import引入，以使用该模块中的函数等功能。

1
import module1, module2, ...

一个模块被另一个程序第一次引用的时候，其主程序将被运行。我们可以使用__name__属性来使得程序块仅在模块自身运行时执行：

1
2
3
4
if __name__ == '__main__':
    # 模块自身运行
else:
    # 来自其他模块

内置的dir()函数可以找到模块内定义的所有名称，以一个字符串列表的形式返回

包是一种管理Python模块命名空间的形式，在包中组织了目录的层级关系。目录只有包含了一个叫做__init__.py的文件才会被认作是一个包，在这个文件中可以包含一些初始化代码等，当然也可以什么都不写。

注意，如果是使用形如from package import item引入的时候，item既可以是包中的子模块，也可以是包中定义的其他名称，比如函数，类或者变量。如果是使用形如import item.subitem.subsubitem这种形式引入的时候，则除了最后一项，其他的都必须是包，并且最后一项可以是模块或者包，但是不可以是类、函数或者变量的名字。

当我们引入一个包的时候，会执行它的__init__.py文件，因此在这个文件我们可以定义一些初始化操作。在这个文件中，我们也可以定义一个名称为__all__的列表变量，这样如果我们使用形如from package import *的形式引入的话，就会引入__all__列表变量中定义的相关模块。如果此时__all__没有定义的话，则不会导入包中的任何子模块。不过总结来说，我们还是推荐使用from package import sepcific_submodule这种形式来引入。

错误和异常

异常处理机制：

1
2
3
4
5
6
7
8
9
10
try:
    #...需要捕获异常的代码块
except RuntimeError as err:
    # ...有异常时的执行代码
except:
    # ...有异常时的执行代码
else:
    # ...没有异常时的执行的代码
finally:
    # ...最终一定会执行的代码

抛出异常使用raise关键字。我们也可以创建一个新的异常类，它需要直接或者间接继承Exception。

面向对象

基础

1
2
3
4
5
6
7
8
9
10
11
12
13
class Person:
    name = ""
    age = 18
    gender = "man"
    __weight = 0  # 私有属性

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def say(self):
        print("Person[name:{name}, age:{age}, gender:{gender}".format(name=self.name, age=self.age, gender=self.gender))
  • 构造方法为__init__()
  • 以单下划线开头的属性是protected类型的，以双下划线开头的属性是private类型的
  • 以双下划线开头和结尾代表Python里的特殊方法
1
2
3
4
5
6
7
8
9
class Student(Person):
    grade = 100

    def __init__(self, name, age, gender, grade):
        Person.__init__(self, name, age, gender)
        self.grade = grade

    def say(self):
        print("I am a Student, my grade is " + str(self.grade))
  • 可以在继承中使用父类的构造函数
  • 同名重写父类方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Speaker:
    name = ""
    topic = ""

    def __init__(self, name, topic):
        self.name = name
        self.topic = topic

    def say(self):
        print("I am a speaker, my topic is " + self.topic)


class Me(Student, Speaker):
    hobby = ""

    def __init__(self, name, age, gender, grade, topic, hobby):
        Student.__init__(self, name, age, gender, grade)
        Speaker.__init__(self, name, topic)
        self.hobby = hobby

    def say(self):
        super(Me, self).say()  # 调用父类的方法
  • 直接通过指定多个父类来实现多继承
  • 如果父类中有相同的方法名，而子类使用的时候没有指定，则Python从继承列表中从左到右搜索
  • 使用super()来调用父类中的方法

类属性和方法：

  • 类的私有属性以两个下划线开头，不能在类的外部被使用或直接访问
  • 类的私有方法以两个下划线开头，只能在类的内部调用

特殊方法

在Python中，类存在一些特殊方法，即前后均为双下划线的方法。这些特殊方法有着各自的功能。

专有方法 描述
__new__ 创建类实例时会被调用，优先于构造函数执行
__init__ 构造函数
__del__ 析构函数
__str__ 对象的字符串表示，用于print
__repr__ 对象的字符串表示，一般用于调试
__setitem__ 按照索引赋值
__getitem__ 实现通过索引取值
__len__ 获取长度
__cmp__ 比较运算
__call__ 直接对实例进行调用，就像使用函数一样
__add__ 加运算，用于运算符重载
__sub__ 减运算，用于运算符重载
__mul__ 乘运算，用于运算符重载
__truediv__ 除运算，用于运算符重载
__mod__ 求余运算，用于运算符重载
__pow__ 乘方运算，用于运算符重载
  • hasattr()函数

hasattr()函数用来判断某个类实例对象是否包含指定名称的属性或者方法，用法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# hasattr(obj, name)

class Cat:
    def __init__(self):
        self.name = "mm"
        self.master = "hh"

    def miao(self):
        print("mmmm...")


cat = Cat()
print(hasattr(cat, "name")) # True
print(hasattr(cat, "master")) # True
print(hasattr(cat, "miao")) # True
print(hasattr(cat, "mother")) # False
  • getattr()函数

getattr()函数用来获取某个类实例对象中指定属性的值，如果不存在对应属性，则判断是否设定了默认值。如果有则返回默认值，如果没有则报错AttributeError：

1
2
3
4
5
6
# getattr(obj, name[, default])

cat = Cat() 
print(getattr(cat, "name")) # mm
print(getattr(cat, "master")) # hh
print(getattr(cat, "mother", "ww")) # ww
  • setattr()函数

setattr()函数可以用来修改实例对象中的属性值，也可以实现为实例对象动态添加属性或者方法：

1
2
3
4
5
6
7
8
9
10
11
# setattr(obj, name, value)

cat = Cat()
# 设置属性值或方法
setattr(cat, "name", "123")
setattr(cat, "master", "456")
setattr(cat, "miao", lambda: print("xxxxxx..."))

# 添加属性或方法
setattr(cat, "add", 789)
setattr(cat, "run", lambda: print("run...."))

迭代器与生成器

迭代器

迭代器是一个可以记住遍历位置的对象，它从集合的第一个元素开始访问，知道所有的元素都被访问结束。迭代器只能往前而不能后退。我们需要利用iter()方法来创建一个迭代器对象，然后使用其中提供的一个next方法来访问下一个元素，我们也可以用常规的for来遍历一个迭代器对象。

1
2
3
4
a = [1, 2, 3, 4]
it = iter(a) # 创建迭代器对象
print(next(it)) # 1
print(next(it)) # 2

我们也可自己创建一个迭代器，只需要在自定义的类中实现两个方法__iter__()以及__next__()方法：

  • __iter__()：返回一个迭代器对象，这个对象实现了__next__()方法，并通过StopIteration异常来标识迭代的完成
  • __next__()：返回下一个值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class MyNumbers:
    def __iter__(self):
        self.num = 1
        return self

    def __next__(self):
        if self.num > 20:
            raise StopIteration
        x = self.num
        self.num += 2
        return x


myNumbers = MyNumbers()
myIter = iter(myNumbers)

print(next(myIter)) # 1
print(next(myIter)) # 3
print("---") # ---

for i in myIter:
    print(i) # 1 3 5 ... 17 19

生成器

使用了yield的函数被称生成器（Generator）。生成器是一个返回迭代器的函数，只能用于迭代操作，我们可以将生成器理解为一个迭代器。在每次调用生成器的时候，遇到yield函数会暂停并保存当前的运行信息，返回yield的值，直到下一次调用next方法的时候再从当前位置继续运行。

1
2
3
4
5
6
7
8
9
10
def generateOdd(n):
    a = 1
    while a < n:
        yield a
        a += 2


it = generateOdd(26)  # it为一个迭代器，由生成器返回生成
for i in it:
    print(i)

依赖生成

一个好的习惯是对于每一个Python项目都准备一个对应的虚拟环境，这样可以保证不同项目之间的环境不会产生冲突。在Python中也提供了相关的命令来查看当前的依赖项，下面的命令可以列出当前环境中的依赖项。

1
pip freeze

不过直接使用该命令可能会输出一些路径信息而非版本信息，此时使用下面的命令可以解决：

1
pip list --format=freeze

通常情况下，我们会将项目的依赖项以及相关版本都存放在requirements.txt文件当中，此时我们将上面命令的输出进行重定向即可。同时，我们也可以很轻易地通过这个文件进行依赖项的安装，通过下面的命令即可：

1
pip install -r requirements.txt

参考文章

  1. Python3 教程 | 菜鸟教程 (runoob.com)
  2. Python类特殊成员（属性和方法） (biancheng.net)
后端 > Python
#Python #笔记
Python基础笔记(1)-Python速览
http://example.com/2022/10/25/Python基础笔记-1-Python速览/
作者
EverNorif
发布于
2022年10月25日
许可协议