Python编程：从入门到实践_注释笔记

发表于 | 分类于

字符串

1
2
3
4
5
6
7
name.title()            # 首字母大写
name.upper()    
name.lower()            # 转换大小写
name.rstrip()   
name.lstrip()
name.strip()            # 删除右边/左边/两边的空格
"age" + 12              # 会报错，应使用str()方法将数字转换成字符串

列表

元素操作

1
2
3
4
5
6
list.append(item)       # 新增
list.insert(0,item)     # 插入
del list[1]             # 删除某索引元素
list.pop()              # 删除列表末尾元素，并返回它
list.pop(2)             # 弹出列表中某索引的元素，并返回它
list.remove('alan')     # 根据值来删除元素，只删除第一个符合的

组织列表

1
2
3
4
list.sort()             # 永久排序，改变自身
sorted(list)            # 临时排序，不改变列表
list.reverse()          # 按索引反转列表，改变自身
len(list)               # 计算列表长度

操作列表

遍历
1
2
for item in list:
    pass
创建数值列表
1
range(1,5)              # 左闭右开，1,2,3,4
简单统计
1
2
3
min(list)
max(list)
sum(list)
列表推导式
1
squares = [item**2 for item in range(1,11)] # 返回从1-10的平方的列表
切片
1
2
3
list[0:3]               # 返回索引为0-2的元素列表，左闭右开
list[:3]                # 冒号左边缺省则默认从0，右边缺省则默认列表的length
list[:]                 # 浅复制整个列表

元组

tuple = (30,100)
不可变的列表称为元组
遍历元组同列表一样，元组元素不可修改，但是可以重新定义整个元组变量

字典

dict = {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
dict['name'] = 'alan'   # 新增/更新
del dict['name']        # 删除
dict.pop('name')        # 删除并返回

items()                 # 返回由字典每一对键值构成的元组的列表
keys()                  # 返回字典所有键组成的列表
values()                # 返回值的列表

for key,value in dict.items():      # 遍历
    pass

for key in sorted(dict.keys()):     # 按字符顺序遍历
    pass

for value in set(dict.values()):    # 获取唯一不重复的值
    pass

if 'name' in dict.keys():           # 判断键值是否存在
    pass

while循环

假值

1
2
3
4
5
6
d = {}
l = []
set1 = set()
t = tuple()
i = 0
str1 = ''

假值转换为bool时为False,如
if not set1:/while l:

移动元素

1
2
3
4
5
arr1 = ['str1', 'str2', 'str3']
arr2 = []

while arr1:
    arr2.append(arr1.pop())

删除特定元素

1
2
3
4
arr1 = ['str1', 'str2', 'str3', 'str1']

while 'str1' in arr1:
    arr1.remove('str1')

函数

定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def funcname(p1, p2='dog'):     # 可选参数
    pass

funcname('123', p2='cat')       # 通过关键字传递实参

funcname( arr[:] )              # 传递列表副本，避免被函数内部修改

def make(name,*args):           # 可传递任意数量的实参，必须放在其他形参之后
    print(args)                 # 创建一个参数组成的元组

make('a1','a2','3')             
make()                          # 空元组
    
def make(name, **kwargs):       # 传递任意数量的关键字实参
    profile = {'name': name}
    for key, value in kwargs.items():
        profile[key] = value
    return profile

print make('alan', age=20, gender='male')

导入

1
2
3
import make as m            # 设置别名
from make import remake     # 导入特定函数
from make import *          # 导入所有函数，调用时不再需要模块名前缀

类

定义类和方法

1
2
3
4
5
6
7
8
9
class Dog():                # python 3.x
    def __init__(self, name):       # self代表实例自身的引用
        self.name = name

    def sit(self):
        print(self.name+"is sitting")

class Dob(object):          # python 2.7
    pass

继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# car.py

"""this is a car module"""

class Car():
    def __init__(self, model):
        self.model = model

    def fill_gas(self):
        print('filling')

class ElectricCar(Car):
    def __init__(self, model):
        super().__init__(model)

    def fill_gas(self):
        print('not need gas')


from car import ElectricCar
c = ElectricCar('ss')
c.fill_gas()

from car import Car,ElectricCar     # 导入模块中的多个类

import car                          # 导入整个模块

from car import *                   # 导入模块中的所有类

Python标准库

1
2
3
4
5
6
7
8
9
# OrderedDict

from collections import OrderedDict

dict = OrderedDict()
dict['sarah'] = 'c'
dict['jen'] = 'python'
dict['phil'] = 'ruby'
print(dict)

有序字典，保留数据初始时的顺序

编码风格：
类名：驼峰命名法，首字母大写，不使用下划线
实例名和模块名：小写，单词之间加下划线
模块和类都要包含一个文档字符串
空行的使用：类中使用一个空行分隔方法，模块中使用两个空行来分隔类
导入模块时，先导入标准库模块，再添加一个空行，然后导入自己编写的模块

文件和异常

文件

读取
1
2
3
4
5
6
7
8
9
10
11

with open('test.txt') as txt:
    # 一次读取一行
    for row in txt:
        print(row.strip())

    # 读取全部内容
    print(txt.read())

    # 加载到list中
    lines = txt.readlines()   # list
写入
1
2
3
with open('test.txt','w') as txt:
    txt.write()('123123\n')
    txt.write()('abcabc\n')

参数说明：
r - 读取模式
r+ - 读取和写入
w - 写入模式
a - 附加模式
w和a模式，当文件不存在时则创建

异常

ZeroDivisionError：除以0时抛出
FileNotFoundError：文件未找到时抛出

1
2
3
4
5
6
7

try:
    --skip--
except FileNotFoundError as e:      #发生异常
    pass    
else:                               #未发生异常时
    --skip--

存储数据

json存储和读取
1
2
3
4
5
6
7
8
import json

dic = {'name': 'alan', 'age': 12}
with open('text.txt', 'a') as txt:
    json.dump(dic, txt)             # 存储
with open('text.txt', 'r') as txt:
    re = json.load(txt)             #读取
    print(type(re))                 #dict，自动转换类型

单元测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import unittest
from car import Car

class TestCarMethod(unittest.TestCase):         #测试用例，包含多个单元测试
    def setUp(self):
        self.c = Car()                          #setUp方法，初始化下面要用到的数据

    def test_set(self):
        re = self.c.set_wheels(5)
        self.assertFalse(re)                    #断言方法，表达式是否为False

    def test_get(self):
        wheels = self.c.get_wheels()
        self.assertIn(wheels, range(1, 5))      #值是否包含于列表中

unittest.main()

运行测试用例时，每完成一个单元测试，通过时打印一个句点。引发错误时打印一个E，断言失败时打印F

欢迎打赏