语法

课程介绍

  • 语法
  • 函数
  • 容器
  • 文件
  • 内置模块

Python 环境安装

包括了 Python、Pycharm、typora、语雀

https://www.python.org/

https://www.jetbrains.com/pycharm/

https://typoraio.cn/

https://www.yuque.com/

初识 Python 脚本

输出语句 print

1
print("Hellozachary")

空格与缩进

1
2
3
def main():
    print("Hello zachary")
    print("Welcome to Python")

注释

Python 的注释就是用一个 # 注释的一行话，除了# 还可以用’’’ ‘’’，和””” “””

1
2
3
4
5
6
7
8
9
# 这是一个单行注释

'''
这是一个多行注释
'''

"""
这也是一个多行注释
"""

语句跨行

使用反斜杠是语句分行编写

1
2
3
for i in \
range(9):
    print(i)

变量（标识符：变量名、函数名、类名、模块名）

用于记录可变化的数据

1
2
num=10
print(num)

变量的命名规范

  • 变量名可以使用字母、数字、下划线，
  • 但是不能以数字开头
  • 要严格区分大小写
  • 不要使用中文
  • 不要使用关键字

关键字包括不限于：

变量定义及数据交换

变量的定义方式

1
2
3
4
5
6
7
8
#第一种
a=10
b=20
print(a,b)

#第二种
a,b=10,20
print(a,b)

交换变量的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#普通方式交换数据
a=10
b=20

t=a
a=b
b=t
print(a,b)

#python独有的方法进行数据交换
a=10
b=20
a,b=b,a
print(a,b)

Python 的数据类型

什么是数据类型——数据的表现形式，常用的包括有数字、字符串，在程序中我们常使用的包括：

字符串类型

1
2
3
4
5
love='Iloveyou'
name="Zachary"

print(love)
print(name)

可以使用type()查看变量的数据类型

1
2
3
4
5
6
#大字符串
s='''
比如这是一个很长的字符串
可以换行的
'''
print(s)

字符串中使用引号可以嵌套使用，单双引号可以互相嵌套，但是不可以嵌套自己

1
2
s="I'mZachary"
print(s)

关于转义字符

\t 制表符
\r 换行符
\n 回车换行符
在字符串前面加一个r可以取消转义字符的效果

1
2
3
4
5
6
7
#使用了转义字符的
s="这是一段话\n分了两行"
print(s)

#使用r使转义字符失效
s=r"这是一段话\n没有分两行"
print(s)

数字类型

  • 整型 int
1
2
3
4
var=520
print(var,type(var))
var=-100
print(var,type(var))
  • 浮点类型 float
1
2
var=3.14
print(var,type(var))
  • 复数类型 complex
1
2
var=5+6j
print(var,type(var))
  • 布尔类型 bool(True\False)
1
2
3
4
var=True
print(var,type(var))
var=False
print(var,type(var))

list 列表类型

列表用来表示一系列数据，例如需要记录一组数字或者其他数据，用中括号括起来[],并且数据之间使用,分隔开

1
2
varlist=[192,200,43]
print(varlist,type(varlist))
  • 列表中存储的数据可以是任意类型
  • 列表中存储的每一组数据，称为元素
  • 列表中存储的数据可以通过下标获取，列表的下标从 0 开始，倒着来最后一个是-1
1
2
varlist=[192,200,43]
print(varlist[0])
  • 列表中元素的值，可以是一个 list，这种叫二维列表
1
2
3
varlist=[192,['a','b'],43]
print(varlist,type(varlist))
print(varlist[1][0])#'a'

tuple 元组类型

元组与列表数据类型相似，使用多个数据内容时候也可以使用元组，用括号()括起来，但是区别在于 tuple 的元素不可改变

1
2
vart=(1,2,3,'a','b')
print(vart,type(vart))
  • 注意，在定义元组时候，如果只有一个元素，需要加一个逗号,
1
2
vart=('abc',)
print(vart)
  • 列表使用中括号[]定义，元组使用括号()定义
  • 列表中的值可以被改变，元组中的值不可以

dict 字典类型

字典也是用于存储一组或多组数据，使用大括号{}括起来，使用的是键-值对的存储方式

  • 使用键-值对的方式进行定义，{ key:value }
  • 键和值之间使用冒号:进行分隔，多组键-值对之间用逗号,分隔
  • 键-必须是字符串或者数字类型，值-可以是任意类型
  • 键-不可以重复，值-可以重复
1
2
3
4
5
6
7
8
vard={
'title':'<<无人生还>>',
'author':'阿加莎·克里斯蒂',
'price':'39.99'
}
print(vard,type(vard))
#通过索引键名来获得对应值，类似于list的方式
print(vard['title'])

set 集合类型

集合是一种用于存储无重复的数据，使用大括号{}或者 set()方法来定义

  • 集合是一种无序且无重复的数据类型
  • 使用 set 方法定义的时候，里面是字符串
  • 当需要定义一个空集合的时候，只能使用 set 方法，因为{}是一个空字典
1
2
3
4
5
6
7
8
9
vars={1,2,3,4,'a','b',1,2,3}
print(vars,type(vars))#{1,2,3,4,'a','b'}<class'set'>

vars=set("123")
print(vars)#{'1','3','2'}
vars=set()
print(vars,type(vars))#set()<class'set'>
vard={}
print(vard,type(vard))#{}<class'dict'>
  • 可以给集合添加元素，使用 add 方法
  • 可以删除集合中的元素，使用 discard 方法
  • 也可以用in检查元素是否在集合中
1
2
3
4
5
6
vars={1,2,3,4,'a','b',1,2,3}
vars.add('c')
print(vars)#{1,2,3,4,'b','c','a'}
vars.discard(4)
print(vars)#{1,2,3,'c','b','a'}
print(1invars)#True
  • 集合主要用于运算，包括交集、并集、补集，对称集合
1
2
3
4
5
6
a={1,2,3,7,8,9}
b={1,2,'a','b'}
print(a&b)#交集{1,2}
print(a-b)#差集{8,9,3,7}
print(a|b)#并集{1,2,3,7,8,9,'a','b'}
print(a^b)#对称集合{3,'a',7,8,9,'b'}

基础数据类型转换

数据类型总结
字符串 str
数字类型

  • 整型 int
  • 浮点 float
  • 复数 complex
  • 布尔 bool

列表 list
元组 tuple
字典 dict
集合 set

可变数据类型：列表(append)、字典([‘key’])、集合(add)
不可变数据类型：字符串、数字、元组

容器类型数据：字符串、列表、元组、集合、字典
非容器类型数据：数字、布尔类型

数据类型转换：把一个数据类型转化为另一个类型
为什么要进行数据类型转换：因为不同数据类型之间不能进行运算
数据转换的类型：

  • 自动类型转换
    当两个不同类型的值进行运算时，结果会向更高的精度进行计算
    True ===> 整型 ===> 浮点 ===> 复数
1
2
3
4
5
6
#自动类型转换
a=123
b=True
print(a+b)#124
print(12.5+22)#34.5
print(True+3.14)#4.140000000000001
  • 强制类型转换
    分别有：str()、int()、float()、bool()、list()、tuple()、dict()、set()
  1. 可以将所有类型转换为 str
  2. 字符串如果是纯数字可以转化为 int，其他类型容器不行
  3. float 与 int 类似
  4. bool 的强制转化，只要有非 0 值、非空值的内容、容器，结果都是 True

容器类型数据转换

容器类型转换为

  • list 列表

数字不能转换，因为 int 和 float 都是不可迭代的，非容器类型
字符串可以转换，会把字符串中的每一个字符当做一个元素
集合、元组、字典都可以转换，字典会只保留键

1
2
3
4
5
6
7
8
#list列表
n='123'
res=list(n)
print(n,type(n))#123<class'str'>
print(res,type(res))#['1','2','3']<class'list'>
n={'a':1,'b':2}
res=list(n)
print(res)#['a','b']
  • tuple 元组

数字不能转换，因为 int 和 float 都是不可迭代的，非容器类型
字符串可以转换，会把字符串中的每一个字符当做一个元素
集合、列表、字典也都可以转换，同上只保留键

  • set 集合

数字不能转换，因为 int 和 float 都是不可迭代的，非容器类型
字符串可以转换，会把字符串中的每一个字符当做一个元素，并且是无序的
列表、元组、字典也都可以转换，字典只保留键

  • dict 字典

数字不能转换，因为 int 和 float 都是不可迭代的，非容器类型
字符串不可以转换
列表转化的时候必须是嵌套的形式才可以，二级列表,并且每个元素是一个二元素的列表
元组转化的时候，同列表必须是二级元组，每一个元素是一个二元素的元组
集合不可以转为字典

1
2
3
4
5
6
7
8
# 列表转化为字典
n = [['a', 1], ['b', 2]]
res = dict(n)
print(res)  # {'a': 1, 'b': 2}
# 元组转化为字典
n = (('a', 1), ('b', 2))
res = dict(n)
print(res)  # {'a': 1, 'b': 2}

运算符

算数运算符

    • 加
    • 减
    • 乘
  • /   除
  • %   取余（取模）
  • // 取整
  • ** 乘方

字符运算符

  • 字符串与数字不能直接进行运算
  • 字符串与字符串可以使用 + 进行拼接
  • 字符串如果和数字使用 * 那就是重复数字次的字符串
  • 在字符串中如果出现变量，可以使用{} 将变量括起来，然后再字符串前面加上f
1
2
3
4
5
l = "love"
print(l * 3)  # lovelovelove

s = f"I {l} you"
print(s)  # I love you

赋值运算符

  • =   简单的赋值运算符
  • +=   加法赋值运算符
  • -=   减法赋值运算符
  • *= 乘法赋值运算符
  • /=   除法赋值运算符
  • %=   取余赋值运算符
  • **= 乘方赋值运算符
  • //= 取整赋值运算符
1
2
3
a = 12
a += 12
print(a) # 24

比较运算符

  • == 比较两个值是否相等，返回 True、False
  • != 比较两个值是否不相等

  • 大于，返回 True，否则 False

  • <   小于，返回 True，否则 False

  • = 大于等于，返回 True，否则 False

  • <= 小于等于，返回 True，否则 False
1
2
b = 12
print(a != b) # True

逻辑运算符

  • and   与
  • or   或
  • not   非

有一个贪心原则，当 and 的时候前一个是 False，后一个就不计算了，直接返回 False，当 or 的时候，如果前一个是 True 则返回 True，否则返回后一个的情况

位运算

位运算是在二进制上使用的，可以使用 bin()方法将其他进制转换成二进制

  • & 按位与运算
  • | 按位或运算
  • ^ 按位异或运算
  • ~ 按位取反运算
  • << 左移运算

  • 右移运算

其他运算符

  • 成员运算符

in     该成员是否在该数据中
not in   该成员是否不在该数据中

  • 身份运算符

is 检测两个标识符是否引自同一个对象
not is 两个标识符不是引自同一个对象

id()可以用于获取对象地址

流程控制

流程控制有顺序、分支、循环等

分支结构

  • 在分支中常使用的是 if-else 语句
1
2
3
4
if 条件1:
    code1
else:
    code2
  • 该分支可以嵌套，重复等等叠加使用
1
2
3
4
5
6
if 条件1:
    code1
elif 条件2:
    code2
else:
    code3
  • 三元运算符
1
code1 if 条件1 else code2

循环结构

while 循环

1
2
3
4
5
6
num = 1
while num < 10:
    print(num)
    num += 1
else:
    print("循环结束啦")

for 循环

1
2
for i in range(10):
    print(i)
  • break 语句

跳出循环

  • continue 语句

跳出当前循环，执行下一次循环

  • pass 语句

什么也不做

  • exit()和 quit()用于结束程序的，结束的是解释器的程序

打印矩形

打印出十行十列的符号

1
2
for i in range(10):
    print("✨✨✨✨✨✨✨✨✨✨")

隔一行换一个颜色

1
2
3
4
5
for i in range(10):
    if i % 2 == 0:
        print("❤ ❤ ❤ ❤ ❤ ❤ ❤ ❤ ❤ ❤")
    else:
        print("◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇")

打印乘法表

1
2
3
4
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j}✖{i}={i*j}",end="\t")
    print()

打印斐波那契数列

1
2
3
4
5
6
7
num = 10

res_list = [0, 1]
for i in range(num-2):
    res_list.append(res_list[-1]+res_list[-2])

print(res_list)

百元买百鸡

一共有 100 元，买 100 只鸡
公鸡=3 元
母鸡=1 元
小鸡===0.5 元
罗列出所有方案

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
# 公鸡 3
# 母鸡 1
# 小鸡 0.5

money = 100
cock_price = 3
hen_price = 1
chick_price = 0.5
count = 0

cock_max = money // cock_price
hen_max = money // hen_price
chick_max = int(money // chick_price)
print(cock_max, hen_max, chick_max)  # 33 100 200

for cock_num in range(1, cock_max + 1):
    for hen_num in range(1, hen_max + 1):
        money_res = money - cock_num * cock_price - hen_num * hen_price
        if money_res <=0:
            break
        else:
            chick_num = int(money_res // chick_price)
            if cock_num+hen_num+chick_num == 100:
                count += 1
                print(f"方案{count}————100元可以购买:{cock_num}只公鸡，{hen_num}只母鸡，{chick_num}只小鸡")

求 1000 以内的水仙花数

打印 1000 以内所有满足水仙花的数，“水仙花数”是指一个三位数其各位数字的立方和等于该数本身，例如 153 是“水仙花数”，因为：153 = 1^3 + 5^3 + 3^3

1
2
3
4
5
6
for num in range(100, 1000):
    a = num // 100
    b = num % 100 // 10
    c = num % 100 % 10
    if a*a*a+b*b*b+c*c*c == num:
        print(num)

青蛙跳台阶问题

困难：一共有 n 个台阶，一只青蛙每次只能跳一阶或是两阶，那么一共有多少种跳到顶端的方案？例如 n=2，那么一共有两种方案，一次性跳两阶或是每次跳一阶。

动态规划：其实，就是利用，上次得到的结果，给下一次作参考，下一次就能利用上次的结果快速得到结果，依次类推

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 方法一
n = 10
a = 1
b = 2

for i in range(n-2):
    t = a
    a = b
    b += t
print(b)


# 方法二
num = 10

res_list = [1, 2]
for i in range(num-2):
    res_list.append(res_list[-1]+res_list[-2])

print(res_list[-1])

更新: 2024-08-01 16:25:27
原文: https://www.yuque.com/zacharyblock/cx2om6/slzd0tdgv6rm1nk1