My Awesome Project

Appearance

基础语法 ​

一、前置基础 ​

1. 注释 ​

py
# 单行注释

""""
多行注释
"""

'''
多行注释
'''

2. 变量 ​

可以发生改变的一个量，用来区分不同数据的，可以指向一个内存空间，存储一些数据

3. 命名规范 ​

1 必须数字、或字母、或下划线组成

2 不能以数字开头，更不能是纯数字

3 不能用 python 的关键字

4 建议不要用中文

5 建议不要太长

6 建议要有意义

7 推荐使用下划线、或驼峰命名

8 要让人看得懂

3. None ​

py
# None 单纯就是空，表示没有的意思
a = None
print(type(a)) # <class 'NoneType'>

二、基础数据类型 ​

数据类型：区分不同的数据，不同的数据类型应该有不同的操作

1. 数字 ​

  • 整数 int

  • 小数 float

2. 文字 ​

py
表示方式：
  '' 单行
  "" 单行
  ''' ''' 多行
  """ """ 多行
操作：
  + 左右两端必须是数字，表示字符串连接操作
  * 一个字符串只能乘以一个数字，表示字符串重复的次数

3. 布尔 ​

py
布尔值主要有两个：
 True 真 真命题
 False 假 假命题

非0的数字都是True，0是False

三、条件判断 ​

1. if 语句 ​

py
# if语句的预发规则：

# 第一种
if 条件:
 代码

如果条件成立，程序执行
如果添加不成立，程序不执行
a = 500
if a > 300:
  print(123)

# 第二种
if 条件:
 代码1
else:
 代码2

# 如果条件成立，执行代码1，否则，执行代码2
if a > 500:
 print(123)
else:
 print(456)

# 第三种
if 语句嵌套

if a> 500:
 if a > 1000:
  print(1)
 else:
  print(2)
else:
 print(3)

# 第四种
if 条件1:
 代码1
elif 条件2:
 代码2
elif 条件3::
 代码3
 ......
else:
 代码xxx

if a > 500:
 print(1)
elif a > 1000:
 print(2)
else:
 print(3)

2. while 循环 ​

py
while 条件:
 代码

过程：判断条件是否为真，如果为真，执行代码，重复循环，直到条件为假，终止程序
# 1+2+3....+100=?
i = 1
s = 0
while i <= 100:
 s = s + i
 i = i + 1
print(s)

2. for 循环 ​

py
for 变量 in 可迭代的东西：
 代码

把可迭代的东西的每一项内容拿出来，挨个的赋值给变量，每次赋值都要执行一次循环体

for循环想要计数，必须借助于range

range(n): 从0到n，不包含n
range(m, n): 从m到n，不包含n
range(m, n, s): 从m到n，不包含n，每次间隔是s

for i in range(10):
 print(i) # 打印0 ~ 9

for i in range(3, 10):
 print(i) # 打印3 ~ 9

for i in range(1, 10, 2):
 print(i) # 打印1 3 5 7 9

break: 让当前这个循环立即停止
continue: 停止当前本次循环，继续执行下一次循环

四、字符串 ​

字符串操作不会对原字符串产生影响，一般返回一个新的字符串

1. 字符串格式化 ​

py
# %s 字符串占位
# %d 整数占位
# %f 小数占位，原样输出，python3精度默认小数点后6位，（最后一位四舍五入）

name = '张三'
age = 20
money = 100.01
s = '姓名: %s, 年龄: %d, 金额: %f' % (name, age, money)
print(s) # 姓名: 张三, 年龄: 20, 金额: 100.010000
print(money) # 100.01


s1 = '姓名: {}, 年龄: {}, 金额: {}'.format(name, age, money)
print(s1) # 姓名: 张三, 年龄: 20, 金额: 100.01


s2 = f'姓名: {name}, 年龄: {age}, 金额: {money}'
print(s2) # 姓名: 张三, 年龄: 20, 金额: 100.01

2. 索引和切片 ​

py
# 索引：按照位置提取元素
s = 'hello'

# 正数，从0开始
print(s[1]) # e

# - 符号表示倒数
print(s[-1]) # o


# 切片：从字符串中提取一部分内容
# s[start:end] 从start到end切片，可以取start，不能取end，左闭右开
# 从索引1切片到索引3结束，左闭右开
print(s[1:3]) # el

# 如果start从0开始，可以省略
print(s[:3]) # hel

# 如果一直截取到末尾，end可以省略
print(s[1:]) # ello

# : 如果左右两端有空格，表示从到到尾
print(s[:]) # hello


# 负数和正数一样，从左往右切
print(s[-3:-1]) # ll
print(s[-1:-3]) # 没有结果


# 从右往左切，需要加步长来控制方向
# 语法：s[start:end:step] 从start到end切片，然后每step个元素分组，取第一个元素

s = 'abcdefghijklmnopqrstuvwxyz'
# 如果step 大于0，就是从左往右，默认为正
print(s[2:11:3]) # cdefghij > cde fgh ij > cfi

# 如果step 小于0，就是从右往左
print(s[-2:-10:-3]) # rstuvwxy > rs tuv wxy > yvs

3. 字符串大小转化 ​

py
# 第一个字母大写

s = 'python'
s1 = s.capitalize()
print(s1) # Python

# 所有单词的首字母大写
s = 'i have a dream'
s1 = s.title()
print(s1) # I Have A Dream

# 所有字母变成小写
s = 'I HAVE A DREAM'
s1 = s.lower()
print(s1) # i have a dream

# 所有字母变成大写
s = 'i have a dream'
s1 = s.upper()
print(s1) # I HAVE A DREAM
# 忽略大小写判断，就全部转成大写进行判断--upper

4. 替换 ​

py
# strip() 去掉字符串左右两端的空白符(空格 t n)

s = ' hello '
print(s.strip()) # hello


# replace(old, new) 字符串替换
s = 'hello wold a'
print(s.replace(" ", "")) # hellowolda

5. 切割 ​

py
# split() 字符串切割
s = 'hello_world'
print(s.split('_')) # ['hello', 'world']

6. 查找 ​

py
s = 'hello wold a'

# find 返回-1表示没有该字符串出现
print(s.find('hello')) # 0 没有就-1，在就返回索引位置
print(s.index('hello')) # 0 没有就报错，在就返回索引位置


# in 条件判断，返回True 或False
print('hello' in s) # True


# not in 判断不在里面
print('hello' not in s) # False



# startswith 判断字符串是否以xxx开头
# endswith 判断字符串是否以xxx结尾
# isdigit 判断字符串是否由整数组成
# isdecimal 判断字符串是否由小数组成

7. 字符串长度 ​

py
# len 返回字符串长度
s = 'hello'
print(len(s)) # 5

8. 连接 ​

py
# join 连接字符串
list = ['a', 'b', 'c']
print('_'.join(list)) # a_b_c

五、列表 ​

1. 定义 ​

py
# [] 表示列表，元素通过 , 隔开
list = ['a', 'b', 'c']

# 特性
# 1 有索引和切片
# 2 超过索引就保持
# 3 可以用for循环进行遍历
# 4 可以用len拿到列表的长度

2. 新增 ​

py
list = []

# append() 追加
list.append('a')
list.append('b')
print(list) # ['a', 'b']


# insert() 插入
list.insert(0, 'c')
print(list) # ['c', 'a', 'b']


# extend() 可以合并两个列表，批量添加
list.extend(['d', 'e'])
print(list) # ['c', 'a', 'b', 'd', 'e']

3. 删除 ​

py
# pop() 给出被删除的索引，返回被删除的元素
list = ['c', 'a', 'b', 'd', 'e']
ret = list.pop(3)
print(ret) # d
print(list) # ['c', 'a', 'b', 'e']


# remove() 删除某个元素
list = ['c', 'a', 'b', 'd', 'e']
list.remove('d')
print(list) # ['c', 'a', 'b', 'e']

4. 修改 ​

py
# 直接用索引修改
list = ['c', 'a', 'b', 'd', 'e']
list[3] = 'f'
print(list) # ['c', 'a', 'b', 'f', 'e']

5. 查询 ​

py
# 直接用索引查询
list = ['c', 'a', 'b', 'd', 'e']
print(list[3]) # d

6. 循环 ​

py
list = ['c', 'a', 'b', 'd', 'e']
# 循环数据项
for item in list:
 print(item)

7. 循环索引 ​

py
for i in range(len(list)):
 print(list[i])

8. 排序 ​

py
# 列表，默认有序，按照存放顺序保存
list = [1, 3, 4, 2]

# sort() 升序排列
list.sort()
print(list) # [1, 2, 3, 4]


# sort(reverse=True) 降序排列
list.sort(reverse=True)
print(list) # [4, 3, 2, 1]

9. 嵌套查找 ​

py
list = [1, 3, 4, 2, [11, 22, '哈哈']]
print(list[4][2]) # 哈哈

六、元祖 ​

1. 定义 ​

py
# tuple 元祖， 特点：不可变
t = ('a', 'b')
print(t) # ('a', 'b')
print(t[1]) # b
print(t[1:3]) # ('b',)


# t[0] = 'c' # TypeError: 'tuple' object does not support item assignment
# print(t)

2. 使用场景 ​

固定数据，不允许外界修改

py
# 元祖如果只有一个元素，就变成了字符串了
t = ('a')
print(t) # a


# 如果需要变成元祖，需要加个逗号
t = ('a', )
print(t) # ('a',)


# 元祖不可变，指的是当前层级的内存地址不能变，里面内容还是可以变的
t = (1, 2, 3, ['a', 'b'])
t[3].append('c')
print(t) # (1, 2, 3, ['a', 'b', 'c'])

七、集合 ​

1. 定义 ​

py
# set集合 无序
s = {1, 2, 3, []}
print(s)
# TypeError: unhashable type: 'list'

# 不可哈希：
# set集合进行数据存储的时候，需要对数据进行哈希计算，根据计算出来的哈希值进行存储数据
# set集合要求存储的数据必须是可以进行哈希计算的
# 可哈希：不可变的数据类型 int str tuple bool
# 不可哈希：可变的数据类型 list dict set

# 创建空集合
s = set()

2. 新增 ​

py
s.add('a')
s.add('b')
s.add('c')
print(s) # {'a', 'b'}

3. 删除 ​

py
# 集合无序，可能删除的不是最后一个，很少用
s = set(['a','b','c'])

s.pop()
print(s) # {'b', 'c'}
s.remove('c')
print(s) # {'b'}

4. 修改 ​

py
# 修改：先删除，再新增
s = set(['a','b','c'])
s.remove('c')
s.add('c')
print(s) # {'b', 'a', 'c'}

5. 查询 ​

py
# 查询 使用for循环
s = set(['a','b','c'])

for item in s:
 print(item)
# a
# c
# b

5. 交集 并集 差集 ​

py
s1 = {'a', 'b', 'c'}
s2 = {'e', 'c', 'f'}

# 交集
print(s1 & s2) # {'c'}
print(s1.intersection(s2)) # {'c'}

# 并集
print(s1 | s2) # {'c', 'f', 'b', 'e', 'a'}
print(s1.union(s2)) # {'c', 'f', 'b', 'e', 'a'}

# 差集
print(s1 - s2) # {'a', 'b'}
print(s1.difference(s2)) # {'a', 'b'}

6. 集合去重复 ​

py
# 集合作用：去重复
s1 = {'a', 'b'}
s1.add('a')
print(s1) # {'b', 'a'}

7. 数组去重 ​

py
lst = ['a', 'a', 'b', 'b', 'c', 'c']
print(list(set(lst))) # ['b', 'a', 'c']

八、字典 ​

1. 定义 ​

py
# 字典是一键值对的形式进行存储数据的
# 字典的表示方法： {key:value, key2:value2}
dic = {
 'name': '张三',
 'age': 12
}

# 根据索引取值
val = dic['name']
print(val) # 张三

# 字典的key必须是可哈希的数据类型
# 字典的value可以是任何数据类型
# dic = { []: 123 }
# print(dic) # TypeError: unhashable type: 'list'

2. 新增 ​

py
dic = dict()
dic['name'] = '张三'
dic[1] = 123
print(dic) # {'name': '张三', 1: 123}

3. 删除 ​

py
# 根据key删除
dic = dict({'name': '张三', 1: 123})
dic.pop('name')
print(dic) # {1: 123}

4. 修改 ​

py
dic = dict({'name': '张三', 1: 123})
dic['name'] = '李四'
print(dic) # {'name': '李四', 1: 123}


# 设置默认值, 如果之前的key已经有了，setdefault就不起作用了
dic.setdefault('tom', 'test')
print(dic) # {'name': '李四', 1: 123, 'tom': 'test'}
dic.setdefault('tom', 'test2')
print(dic) # {'name': '李四', 1: 123, 'tom': 'test'}

5. 查询 ​

py
dic = dict({'name': '李四', 1: 123})

# 如果key不存在，程序会报错
print(dic['name']) # 李四

# 如果key不存在，程序返回None
print(dic.get('name')) # 李四

6. 循环 ​

py
dic = {
 'name': '张三',
 'age': 12
}

# 1 for循环，直接拿到key
for key in dic:
 print(key, dic[key])

# name 张三
# age 12

# 2 拿到所有的key
print(list(dic.keys())) # ['name', 'age']

# 3 拿到所有的value
print(list(dic.values())) # ['张三', 12]

# 4 拿到key和value
print(list(dic.items())) # [('name', '张三'), ('age', 12)]

7. 嵌套查找 ​

py
dic = {
 'name': '张三',
 'age': 30,
 'child': [
   {
   'name': 'son1',
   'age': 10,
   },
   {
   'name': 'son2',
   'age': 8,
   },
 ]
}

print(dic['child'][0]['name'])
# son1

九、运算符 ​

1. 算数运算符 ​

py
+ 加法
- 减法
* 乘法
/ 除法
% 求余
// 整除

2. 比较运算符 ​

py
> 大于
< 小于
>= 大于等于
<= 小于等于
== 等于
!= 不等于

3. 赋值运算符 ​

py
=
+=
-=
*=

4. 逻辑运算符 ​

py
and 并且 左右两端同时成立，结果才成立
or  或者 左右两端有一个成立，结果就成立
not 非  非真既假，非假即真

当and和or以及not同时成立的时候，最好加括号，如果没有括号就按照运算顺序：
括号 > not > and > or

5. 成员运算符 ​

py
in
not in

十、文件操作 ​

1. 打开文件 ​

py
open(文件路径, mode="", encoding="")

"""
文件路径：
  绝对路径
​    d: /test/xxx.txt
  相对路径
​    相对于你程序所在的文件夹
​    ./ 当前文件夹
​    ../ 上一层文件夹

mode:
  r : read 读取
  w : write 写
  a : append 追加写入
  b : 读取的是非文本文件 -> bytes
"""
py
import os # 和操作系统相关的模块引入

# 打开一个文件
f = open('./test.txt', mode='r', encoding='utf-8')

# 全部读取
print(f.read())

# 读取一行
print(f.readline())

# 全部读取，数组输出
print(f.readlines())

# 循环读取文件方式-最常用
for line in f:
  print(line.strip())

# 写
# w模式下，如果文件不存在，会自动创建一个文件
# w模式下，每一次open都会清空掉文件中的内容
f = open('./test1.txt', mode='w', encoding='utf-8')
f.write('hello, world')
f.close()


# a 模式
f = open('./test1.txt', mode='a', encoding='utf-8')
f.write('hello, world11')
f.close()

2. with ​

py
with: 上下文，不需要手动关闭一个文件

# f= open()
with open('test2.txt', mode='r', encoding='utf-8') as f:
 for line in f:
  print(line.strip())

3. 修改文件 ​

  • 1 从源文件中读取内容

  • 2 再内层中进行调整(修改)

  • 3 把修改后的内容写入新文件中

  • 4 删除源文件，将新文件重命名成源文件

py
# 读取图片
# 读取非文本文件的时候需要加上b
with open('bgirl.png', mode='rb') as f:
 for line in f:
  print(line)

# 文件复制：从源文件读取，然后写入新文件中
# with open('bgirl.png', mode='rb') as f1, open('bgirl2.png', mode='rb') as f2:
with (open('bgirl.png', mode='rb') as f1,
 open('bgirl2.png', mode='wb') as f2):
 for line in f1:
  f2.write(line)

# 文件修改
with open('test3.txt', mode='r', encoding='utf-8') as f1,
 open('test3_副本.txt', mode='w', encoding='utf-8') as f2:
 for line in f1:
  line = line.strip()
  if line.startswith('马'):
   line = line.replace('马', '周')

  f2.write(line)
  f2.write('n')

# 删除源文件
os.remove('test3.txt')

# 把副本文件重命名成源文件
os.rename('test3_副本.txt', 'test3.txt')

十一、函数 ​

1. 定义 ​

py
"""
函数：对某一个特定的功能或者代码块进行封装，再需要使用该功能的时候直接调用即可

定义：
def 函数的名称():
  被封装的功能或代码块 -> 函数体

调用
函数的名称()

参数：可以在函数调用的时候，传递一些信息

分类：
 1 形参：函数定义的时候，需要准备一些变量来接收信息
  1 位置参数，按照位置挨个声明变量
  2 默认参数，在函数声明的时候给变量一个默认值，如果实参不传递，此时默认值生效，否则不生效
  位置参数放前面，默认值在后面

  3 动态传参
   1 *args 表示接收所有的位置参数的动态传参
   2 **kwargs 表示接收所有的关键词的动态传参

  顺序：位置参数 > *args > 默认参数 > **kwargs

 2 实参：实际在调用的时候传递的信息
  1 位置参数，按照位置进行传递参数
  2 关键字参数，按照参数的名字进行传递参数
  3 混合参数，
   顺序：位置参数放前面，关键词参数放后面 -> 否则报错
  4 实参在执行的时候，必须保证形参有值
"""
py
# 1 定义
def buy():
 print('world')

# 调用函数
buy()


# 2 参数
def buy(a):
 print(a)

buy('world')

# 3 动态参数
# * 表示位置参数的动态参数，*接收的值会被统一放到一个元祖里面
def buy(*food):
 print(food)

buy('a', 'b')
# ('a', 'b')

buy('a', 'b', 'c')
# ('a', 'b', 'c')

# ** 表示接收关键字的动态传参，接收到的所有参数都会被处理成字典
def buy(**food):
 print(food)

buy(name = '鱼', money = 15)
# {'name': '鱼', 'money': 15}

def func(a, b, *args, c='hello', **kwargs):
 print(a, b, args, c, kwargs)

func(1, 2, 3, 4, 5, c = 'world', name="test")
# 1 2 (3, 4, 5) world {'name': 'test'}


def func(*args):
 print(args)


lst = ['a', 'b', 'c']
# * 在实参，表示把列表打散成位置参数进行传递
# ** 在实参，表示把字典自动转化为关键词参数进行传递
func(*lst)
# ('a', 'b', 'c')

2. 返回值 ​

py
# 返回值：函数执行完了之后，返回给调用方的结果
# 1 函数不写返回值，默认为None
# 2 只写了return，返回的也是None
# 3 return 会终止一个函数
# 4 return 值， 此时函数有一个返回值，外界能够收到一个数据
# 5 return 值1, 值2, 值3..., 此时函数有多个返回值，外界收到的是元祖，元祖内存放所有的返回值

def func(a, b):
 return a + b

print(func(10, 20)) # 30

def func():
 return 1, 2, 3
print(func()) # (1, 2, 3)

3. 递归 ​

py
# 递归 函数自己调用自己
# python 默认是有递归深度的限制，默认最大深度是1000

4. 函数的嵌套 ​

py
"""
函数可以嵌套函数
 1 函数可以作为返回值进行返回
 2 函数可以作为参数进行相互传递
 3 函数名实际上就是一个变量名，都表示一个内存地址
"""

def func1():
 def func2():
  pass

5. 变量的作用域 ​

py
# 作用域：变量的访问权限

# 全局变量 -> 全局作用域
a = 10

# 全局函数
def func():
 # 局部变量 -> 局部作用域
 b = 20
 print(b)


# global：在局部，引入全局变量
# nonlocal：在局部，引入外层的局部变量

a = 10
def func():
 # global a 把外面的全局变量引入到局部
 global a
 a = 20
 b = 30

 def func1():
  # 向外找一层，如果有变量就引入，没有就继续向外一次，直到全局(但不包括全局)
  nonlocal b
  b = 40

 func1()
 print(b) # 40

func()
print(a) # 20

6. 闭包 ​

py
"""
本质：内层函数对外层函数的局部变量的使用，此时内层函数被称为闭包函数
1 可以让一个变量常驻内存
2 可以避免全局变量被修改
"""

def func():
 a = 10
 def inner():
  print(a)
  return a
 return inner

ret = func1()

Released under the MIT License.

Copyright © 2019-present Evan You