学习笔记：Python

青菜中的油渣
348 阅读9分钟

简介、版本

Python是一门计算机编程语言。目前有两个版本，2.x和3.x版本，笔者学习的是3.x版本。

Python解释器

Python解释器负责解释执行你写的Python代码，编写代码前需要在电脑上安装Python解释器，Python官网有下载链接。

Python运行方式

交互式

在命令行中键入python，即可进入Python交互模式，如果你的电脑有Python的两个版本，键入python3，进入Python3的交互模式。输入exit()退出交互模式

命令行模式

编写.py文件，在命令行中键入python file_name.py，即可执行Python代码。

输入输出函数

name = input('What is your name?')
print('Hello', name)

注释

# 注释代码给程序员阅读，解释器不执行

数据类型、变量

Python数据类型有整数、浮点数、字符串、布尔值、空值，变量是程序中存储数据的地方。

# 十进制数字
a = 10
b = -10
c = 0
d = 2.3e10
f = 1.23e-3
g = 100000 # 可以用下面的大数字表达方法
g = 100_100

# 十六进制数字
h = 0xff

# 字符串
name = 'liqi'

# 转义字符串
message = '\'Hi'

# 不转义字符串
text = r'\\hello'

# 多行字符串
message = '''hello
boy
!
'''

# 布尔值
hasMoney = False
hasPurse = True

# 空值
empty = None

运算

# 算术运算
age = 2000 + 12
score = 100 - 30.5
money = 1000 * 3
num = 10 / 3 # 普通的除法的结果是浮点数
num = 10 // 3 # 地板除的结果是整数，丢弃到余数
num = 10 % 3 # 取余

# 布尔运算：与或非
isShow = True and True
isShow = False or True
isShow = not True

# 逻辑运算
big = 2 > 1

编码、字符串、格式化字符串

  • 计算机只能存储二进制数字，不能直接存储常用的字符，如abc，所以美国人将常用的字符使用一定的规则用数字代替，这就是字符编码。
  • 计算机用8位二进制数字表示字符，常用的字母和符号都有特定的8位二进制数代表，这就是ASCII编码。
  • 一个8位二进制数有8个bit，又称为一个字节1 byte。
  • ASCII编码没有把中文字符编进去，所以中国制定了GB2312编码，把常用的中文字符编入这套编码表中。
  • 不同国家有不同国家的编码表，在一段文本中如果有不同国家的字符，用ASCII解码就会出现乱码，所以为了避免乱码，有人制定了unicode字符集，将所有语言都编码到一套编码表中。
  • 但一个字节无法表示那么多字符，所以unicode编码集就用两个字节表示所有的字符。已经被ASCII编码了的字符直接在前面8位补0，就是unicode的编码规则。
  • 如果是全英文的文本使用unicode编码，会比用ASCII编码更加浪费计算机的存储空间，在传输字符时也多传输了数字。
  • 为了避免浪费的情况，计算机可以将unicode编码的字符转换成utf-8编码，utf-8编码将一个unicode字符转换成合适的大小，常用的unicode英文字符是2个字节，而常用的utf-8英文字符为1个字节，utf-8汉字通常是3个字节。
  • 所以当用记事本编辑文本时，磁盘中的文件以utf-8编码存储，读取到内存后就别为unicode编码，再保存到硬盘或者通过网络传输时，就转换成utf-8编码。
# Python3的字符串就是unicode字符串，可以包含中文等字符
str = '中国'

# 将字符串转换成字节类型bytes
str1 = 'abc'.encode('ascii')
str2 = '中国'.encode('utf-8')

# Python以b''的形式表示bytes

# bytes转换成字符串
str3 = str1.decode('utf-8')
str4 = str2.decode('utf-8')

length = len('中文'.encode('utf-8')

# 格式化字符串
name = 'lq'
height = 3.1415

welcome = 'Hello %s' % name

message = 'Hello %s, you are %d.' % (name, 23)

scores = 'Hello {0}, you are {1:.2f}'.format('lq', 1.23)

# f-string

scores = f'Hello {name}, you are{height: .3f}'

list

list是一种数据类型，有序列表，可增删改

students = ['liqi', 'hy']

length = len(students)

print(students[0])

print(students[-1])

students.append('baby')

students.insert(0, 'we')

print(students)

deletedStudent = students.pop()

print(students)

print(deletedStudent)

students[1] = 'lq'

print(students)

# 二维列表
students = [['liqi', 99], ['hy', 100]]

print(students[1][1])

tuple

也是一种数据类型，也是有序列表，但不可改变，所以它的语法基本跟list相同，但没有修改删除等语法

students = ('liqi', 'hy')

money = ()

height = (1,)

# tuple中的元素可以是可变类型
scores = (100, 99, [100, 99])

scores[2].append(98)

条件判断

age = 18

if age >= 40:
    print('中年')
elif age >= 18:
    print('青年')
else:
    print('未成年')

循环

names = ['lq', 'hy']

for name in names:
    print(name)

# 数学计算
nums = [1,2,3]

sum = 0
for num in nums:
    sum = sum + num
    
sum = 0
for i in range(101):
    sum = sum + i
 

# 100以内奇数之和
sum = 0
num = 99

while num > 0:
    sum = sum + num
    num = num - 2

num = 100
while num > 0:
    print(num)
    num = num -1
    if num < 10:
        break

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0:
        continue
    print(n)

dict、set

# dict，全称dictionary，中文释义：字典，其他语言中成为map，使用键值对 key-value 存储

d = {}

d = {'lq': 99}

d['lq'] = 100

# 访问不存在的key时会报错

print('lq' in d)

print(d.get('hy')) # 不存在key时返回None
print(d.get('hy', False)) # 自定义返回值

value = d.pop('lq')

# key必须是不可变对象，因为dict通过key值来计算value在内存中的位置，
# 通过key来计算位置的算法称为哈希算法：Hash，字符串，数字都是不可变的，所以可以作为key，而list可变，所以不能作为key

# set和dict类似，但不存储value，由于key不能重复，所以set中没有重复的key，而且也不能放入可变对象

s = set()

s = set([1,2,3,3])

s.add(4)

s.remove(3)

# 并集、交集
s1 = set([1,2,3])
s2 = set([1,2,4])

print(s1 & s2)

print(s1 | s2)

print(set([1,2, [2,3]])) # 报错

函数

print(abs(-302.1))

print(max(1,2,3))

# 类型转换
print(int('123'))
print(float('12.30'))
print(str(123))
print(bool(1))
print(bool(''))

# 函数别名
a = abs
print(a(-20.10))

# 类型判断
res = isinstance('x', (int, float, str))
print(res)

# 定义函数
def setName(x):
    return x

def getNone():
    pass

# 返回多个值，其实就是返回一个tuple
def getValue():
    return 1, 2

x, y = getValue()

print(x, y)

# 无return语句，默认返回None

# 位置参数，x和y都是位置参数，调用函数时都得传入
def setValue(x, y):
    print(x, y)

setValue(100, 200)

# 默认参数
def setValue(x, y = 10):
    print(x, y)

setValue(100)

def printStudent(name, age, city = 'beijing', area = 'chaoyang'):
    print(name, age, city, area)

printStudent('liqi', 23, area='jiangning')

printStudent('liqi', 23, area='jiangning', city='nanjing')

printStudent('liqi', 23, 'nanjing', 'jiangning')

# 默认参数不可为可变对象
def setValue(l = []):
    l.append('x')
    print(l)

setValue()
setValue()
setValue() 
# ['x', 'x', 'x']，原因很简单，默认参数在函数定义时指定为一个变量，每次使用这个变量都给它增加值，结果就增加了

# 可变参数
def setValue(*numbers):
    print(numbers)

setValue(1,2,3)

# 可变参数可以在调用函数时传入不限量个参数，这些参数当做一个tuple传递给可变参数变量

# 将一个list或tuple直接当做可变参数传递给函数
names = ['lq', 'hy']
setValue(*names)

# 关键字参数，用户可以给函数传递任意个参数，这些参数在函数内部被组装成dict，和可变参数很像

def setValue(name, age, **kw):
    print(name, age, kw)

setValue('lq', 23, city='nan', area='jianye')

# 也可以把一个dict整体传递给函数
d = {'city': 'nj', 'area': 'jy'}
setValue('lq', 1, **d)

# 命名关键字参数
def setValue(name, age, *, city, job):
    print(name, age, city, job)

setValue('lq', 10, city='njnz', job='it')
# setValue('lq', 10, city='njn') # 缺少参数

# 命名关键字参数是为了限制关键字参数的名称，在调用函数时必须传入名称，*号后面的就是命名关键字参数

def setValue(name, age, *args, city, job):
    print(name, age, args, city, job)

setValue('lq', 100, 'message', 'other message', city='beijing', job='dev')

# 如果有可变参数，那可变参数后面的就都是命名关键字参数

# 名称关键字参数默认值
def setValue(name, *, city='hangzhou'):
    print(name, city)

setValue('lq', city='shanghai')
setValue('ql')

# 参数组合顺序：位置参数、默认参数、可选参数、命名关键字参数、关键字参数
def setValue(name, age = 23, *args, city, **kw):
    print(name, age, args, city, kw)

setValue('lq', 'message', 'other message', city='beijing', text='ok')

切片、迭代、列表生成式、生成器、迭代器

# 递归函数就是调用自身的函数，但使用递归函数要防止栈溢出，因为每次调用函数都会将新函数入栈，只有在函数返回时，才会退栈。
def getValue(n):
    if n == 0:
        return 0
    return n + getValue(n - 1)

sum = getValue(10)

# 可以通过尾递归优化来解决递归调用导致栈溢出的问题，具体就是递归调用时，函数返回值时，调用自身函数，编译器或解释器做优化，只占用一个栈帧。

# 切片操作符slice，可以操作list、tuple、字符串
names = ['lq', 'hy', 'baby']
others = names[0:2]
others = names[:3]
others = names[1:4]
others = names[-2:]
others = names[:3:2]
others = names[:]

names = ('lq', 'hy')
others = names[-1:]

message = 'you are beautiful.'
others = message[-10:-1]


# 迭代可作用于list、tuple等有下标的结构，也可作用于dict等无下标的结构，还有字符串
d = {'name': 'lq', 'age': 23}

for key in d:
    print(key)
    print(d[key])

for value in d.values():
    print(value)

for k, v in d.items():
    print(k, v)

name = 'IT Man'

for char in name:
    print(char)


# 列表生成式
arr = list(range(101))

arr = [x * x for x in range(101)]

arr = [x * x for x in range(101) if x % 2 == 0]

arr = [m + n for m in 'abc' for n in 'xyz']

# for前面是表达式，for后面是过滤条件

# 通过列表生成式可以生成一个列表，而有时候一个大列表比较占内存，而只用到其中的很少一部分，所以这时候就需要用到生成器generator了，
# 生成器保存的是计算的算法，等到真正去计算时，再循环取值

l = (x for x in range(101))
print(l)

next(l)

for n in l:
    print(n)

高阶函数、返回函数、匿名函数、装饰器、偏函数

模块：常用内置模块 datetime collections base64 urllib htmlparser、第三方模块pillow requests chardet

面向对象：类、实例、访问限制、继承、多态、获取对象信息、实例属性、类属性、高级。。

错误、调试错误、测试、单元测试、文档测试

IO编程

进程、线程

正则表达式

图形界面

网络编程：tcp、udp

发送、接收电子邮件

访问数据库

web开发

异步io

microPython

web实战

笔记来源

廖雪峰的官方网站，十分感谢！

avatar
文章
阅读
粉丝