python

1. 基础语法：

1. 计算机基础知识：

1. 计算机的主要构成

主机
显示器
鼠标
键盘

2. 键盘使用

键盘分为三个区域：字符区、字母区和功能区

切换中英文： windows下 shift+ctrl

切换中英文：mac下 ctrl+空格

大小写切换：windows和mac下相同：Caps Lock键（中/英）

特殊符号键：windows和mac下相同：ctrl+特殊符号键，下图为输入感叹号

3. Python编译器介绍

2. print输出：

1. 单行输出

print("Hello Python")

运行结果：

2. 多行输出

print("床前明月光，")
print("疑似地上霜。")

运行结果：

2. 格式化输出

print('%o'%20) #%o表示八进制
print('%d'%20) #%d表示十进制
print('%x'%20) #%x表示十六进制
print('%f'%2.01) #%f表示默认保留6位小数
print('%.3f'%3.1414926) #%.3f表示保留3位小数
print('{} {}'.format('hello','world')) # 格式化参数输出
print('{0} {1}'.format('hello','world')) #带标号对格式化参数输出

运行结果：

2. 变量：

1. 变量定义

变量名第一次出现的时候就是定义变量

2. 变量创建和命名规则

变量创建：变量定义时就是创建了一个新的变量
命名规则：只能由数字、字母、下划线组成，而且不能以数字开头

2. 赋值

形式：变量名=变量值，例如：

num = 123
year = 2021
print(num)
print(year)

运行结果：

2. 运算

x = 5
y = 2
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x % y)
print(x ** y)
print(x // y)

运行结果：

2. 输出

x = 5
y = 2
print("x的值为：",x)
print("y的值为：",y)
print("x加y的值为：",x + y)

运行结果：

2. 局部变量与全局变量 <->函数

函数内部的变量称为局部变量
所有函数的外部的变量称为全局变量

2. input输入：

x = input("请输入一个整数：")
print(x)

运行结果：

2. 数学基础知识：

1. 坐标系

坐标原点的坐标是（0，0）
x轴上原点右边是正坐标，越来越大
x轴上原点左边是负坐标，越来越小
y轴上原点上边是正坐标，越来越大
y轴上原点下边是负坐标，越来越小

1. 数据结构：

1. 整型

不包含小数的正数是整形，比如：5、10、34

2. 浮点型

包含小数的数据类型是浮点型，比如：3.0、4.25、7.1234567

2. 字符串：

1. 字符串定义及创建

var1 = "Hello,world"
var2 = 'Hello,world'
print(var1)
print(var2)

运行结果：

2. 字符串索引

索引从0开始，可以为负值，表示从末尾开始，-1表示最后一个，-2表示倒数第二个

a = "Hello,world"
print(a[0])
print(a[-1])
print(a[-2])

运行结果：

2. 字符串修改

python字符串不可以使用索引直接修改

a = "Hello,world"
a[0] = 'X'
print(a)

运行结果：

2. 字符串替换

a = "Hello,world"
a.replace("world","Python")

运行结果：

2. 字符串添加

用join方法表示添加，下图表示在字符串a,b之间添加空字符、空格和逗号

a = "hello"
b = "World"
print(''.join([a,b]))
print(' '.join([a,b]))
print(','.join([a,b]))

运行结果：

2. 字符串切片

切片表示截取字符串的一部分，语法为s[start:stop]
start表示开始截取的位置，stop表示截取终止的下一个位置

s = "Hello,world"
print(s[1:3])
print(s[:])
print(s[1:])
print(s[:6])

运行结果：

2. 字符串拼接

a="Hello"
b=",World"
print(a+b)

运行结果：

2. 字符串重复

print("ab"*10) #表示输出10个"ab"字符串

运行结果：

2. 字符串分割

a = "a,b,c,d,e"
print(a.split(','))#表示将字符串a以逗号分割开

运行结果：

2. 布尔型：

1. 布尔值

True表示真和False表示假

2. 布尔表达式 <-> 逻辑运算、比较运算

逻辑运算有and,or,not
x and y 表示只有x和y都为真时，表达式才为真，其余为假
x or y表示 x和y都为假时表达式为假，其余为真
not x表示 x为真时，表达式为假，x为假时，表达式为真
比较运算有<,<=,>,>=,==,!=,is,is not
< 表示小于
<= 表示小于等于
>表示大于
>=表示大于等于
==表示等于
!=表示不等于
is表示是对象
is not表示不是对象

print("and的四种情况")
print(True and True)
print(True and False)
print(False and True)
print(False and False)
print("or的四种情况")
print(True or True)
print(True or False)
print(False or True)
print(False or False)
print("not的两种情况")
print(not True)
print(not False)

运行结果：

2. 数据类型的转换：

1. int()
   int()表示将字符串转换为整形

print("12345")
print(int("12345"))
print(type("12345"))
print(type(int("12345")))

运行结果：

2. str()
   str()表示将对象转换为字符串

print(12345)
print(str(12345))
print(type(12345))
print(type(str(12345)))

运行结果：

2. float()
   float()表示将字符串转换为浮点型

print("12345")
print(float("12345"))
print(type("12345"))
print(type(float("12345")))

运行结果：

2. 列表:

1. 列表的定义及创建
   列表可以一次性存储很多数据，是一种有序的数据类型。
   例如：mylist = []
   创建一个列表，只要把逗号分隔的不同数据项使用方括号括起来即可
   比如：list = [1,'hello',3.14,3000]

mylist = []
list = [1,'hello',3.14,3000]
print("mylist列表为：",mylist)
print("list列表为：",list)

运行结果：

2. 列表索引
   列表索引从0开始，也可以倒着开始，-1表示倒数第一个，-2表示倒数第二个

list = [1,'hello',3.14,3000]
print("下面是正数索引：")
print("list[0]的值是：",list[0])
print("list[1]的值是：",list[1])
print("list[2]的值是：",list[2])
print("list[3]的值是：",list[3])
print("下面是负数索引：")
print("list[-1]的值是：",list[-1])
print("list[-2]的值是：",list[-2])
print("list[-3]的值是：",list[-3])
print("list[-4]的值是：",list[-4])

运行结果：

2. 列表切片
   与字符串切片类似。语法为list[start:end]，表示从start开始，到end的前一个结束（不包含end）。也可以省略，start省略表示从头开始，end省略表示到结尾。

list = [1,'hello',3.14,3000]
print("list列表为：",list)
print("list[0:4]列表为：",list[0:4])
print("list[0:]列表为：",list[0:])
print("list[:4]列表为：",list[:4])
print("list[1:3]列表为：",list[1:3])
print("list[2:2]列表为：",list[2:2])

运行结果：

2. 列表插入元素
   list.append(obj)，表示在列表list的末尾添加对象obj

list = [1,'hello',3.14,3000]
print("list列表为：",list)
list.append('python')
print("list列表为：",list)

运行结果：

2. 列表删除元素
   del list[2]表示删除列表list的第三个元素

list = [1,'hello',3.14,3000]
print("list列表为：",list)
del list[2]
print("list列表为：",list)

运行结果：

2. 列表拼接

list1 = [1,3,5]
list2 = [2,4,6]
list3 = list1 + list2
print(list3)

运行结果：

2. 二维列表
   在一个列表中创建另一个列表即为二维列表。
   比如：x = [[1,2,3],['a','b']]

list = [[1,456,3.14,3000],['a',123,'abc']]
print("list列表为：",list)
print("list[1][1]列表为：",list[1][1])
print("第一种遍历方法：")
for x in list:
    print(x)
print("第二种遍历方法：")  
for i in range(len(list)):
    print(list[i])

运行结果：

2. 列表函数 <-> 函数
   len(list)表示求列表元素个数
   max(list)表示求列表元素的最大值
   min(list)表示求列表元素的最小值
   list(s)表示将元组s转换成列表

list = [1,456,3.14,3000]
print("list列表为：",list)
print("len(list)为：",len(list))
print("max(list)为：",max(list))
print("min(list)为：",min(list))

运行结果：

2. 列表遍历
   for x in list:
   for i in range(len(list)):

list = [1,456,3.14,3000]
print("list列表为：",list)
print("第一种遍历方法：")
for x in list:
    print(x)
print("第二种遍历方法：")  
for i in range(len(list)):
    print(list[i])

运行结果：

2. 字典：

1. 字典的定义及创建
   字典是可变容器模型，由键值对组成，中间用冒号分隔，每对之间用逗号分隔，整个表达式用大括号包含，格式如下：{key1:value1,key2:value2,key3:value3}
   创建：dict1 = {'abc':1} dict2 = {'x':234}

dict1 = {'a':1,'b':2,'c':3} 
dict2 = {'A':10,'B':11}
print(dict1)
print(dict2)

运行结果：

2. 字典访问
   把相应的键放入到方括号中，比如：dict1['abc']、dict2['x']

dict1 = {'a':1,'b':2,'c':3} 
dict2 = {'A':10,'B':11}
print("dict1['a']的值为：",dict1['a'])
print("dict2['B']的值为：",dict2['B'])

运行结果：

2. 字典添加元素
   字典中增加键值对即为添加元素，比如：dict1['w'] = 2

dict1 = {'a':1,'b':2,'c':3} 
dict2 = {'A':10,'B':11}
dict1['d'] = 4
dict2['C'] = 12
print("dict1字典为：",dict1)
print("dict2字典为：",dict2)

运行结果：

2. 字典删除元素
   删除单一元素使用del关键字和元素的键，比如：del dict1['abc']
   删除字典：del dict1

dict1 = {'a':1,'b':2,'c':3} 
dict2 = {'A':10,'B':11}
del dict1['c']
del dict2['B']
print("dict1字典为：",dict1)
print("dict2字典为：",dict2)

运行结果：

2. 字典函数 <->函数
   len(dict)表示字典元素的个数，即键的个数
   str(dict)表示输出字典
   type(dict)表示如果dict是字典类型，则返回字典

dict1 = {'a':1,'b':2,'c':3} 
dict2 = {'A':10,'B':11}
print("len(dict1)为：",len(dict1))
print("str(dict2)为：",str(dict2))
print("type(dict2)为：",type(dict2))

运行结果：

2. 字典遍历
   for key in dict1:
   for key in dict2.keys():

dict1 = {'a':1,'b':2,'c':3} 
dict2 = {'A':10,'B':11}
print("遍历dict1:")
for key in dict1:
    print(dict1[key])
print("遍历dict2:")
for key in dict2.keys():
    print(dict2[key])

运行结果：

2. 元组：

1. 元组的定义及创建
   元祖和列表类似，不同之处在于元祖的元素不能被更改元。祖使用小括号定义。
   元祖创建只需要在括号中添加元素并使用逗号分隔，比如
   tup1= (),tup2=(1,2,3),tup3=(3.14,"234",456)

tup1= ()
tup2=(1,2,3)
tup3=(3.14,"234",456)
print("tup1元组为：",tup1)
print("tup2元组为：",tup2)
print("tup3元组为：",tup3)

运行结果：

2. 元组索引
   元组索引从0开始，也可以倒着开始，-1表示倒数第一个，-2表示倒数第二个

tup3=(3.14,"234",456)
print("tup3元组为：",tup3)
print("元组正索引：")
print("tup3[0]元组为：",tup3[0])
print("tup3[1]元组为：",tup3[1])
print("tup3[2]元组为：",tup3[2])
print("元组负索引：")
print("tup3[-1]元组为：",tup3[-1])
print("tup3[-2]元组为：",tup3[-2])
print("tup3[-3]元组为：",tup3[-3])

运行结果：

2. 元组访问
   可以使用下标索引访问元祖的值，比如：tup1[0]

tup3=(3.14,"234",456)
print("tup3元组为：",tup3)
print("元组正索引：")
print("tup3[0]元组为：",tup3[0])
print("tup3[1]元组为：",tup3[1])
print("tup3[2]元组为：",tup3[2])
print("元组负索引：")
print("tup3[-1]元组为：",tup3[-1])
print("tup3[-2]元组为：",tup3[-2])
print("tup3[-3]元组为：",tup3[-3])

运行结果：

2. 元组切片
   元组切片和列表切片类似，语法为list[start:end]，表示从start开始，到end的前一个结束（不包含end）。也可以省略，start省略表示从头开始，end省略表示到结尾。

tup3=(3.14,"234",456)
print("tup3元组为：",tup3)
print("tup3[0:3]元组为：",tup3[0:3])
print("tup3[0:]元组为：",tup3[0:])
print("tup3[:3]元组为：",tup3[:3])
print("tup3[1:2]元组为：",tup3[1:2])
print("tup3[2:2]元组为：",tup3[2:2])

运行结果：

2. 元组修改
   元组的元素不允许修改，但可以对元祖进行拼接，比如：

tup1 = (1,2,3)
tup2 = (4,5,6)
tup3 = tup1+tup2
print(tup3)

运行结果：

1. 控制语句：

1. 分支结构：

1. 单分支if <-> 逻辑运算、比较运算、布尔值
   逻辑运算有and,or,not
   x and y 表示只有x和y都为真时，表达式才为真，其余为假
   x or y表示 x和y都为假时表达式为假，其余为真
   not x表示 x为真时，表达式为假，x为假时，表达式为真
   比较运算有<,<=,>,>=,==,!=,is,is not
   < 表示小于
   <= 表示小于等于
   >表示大于
   >=表示大于等于
   ==表示等于
   !=表示不等于
   布尔值，True表示真，False表示假
2. 双分支if-else
   if 的条件为真，执行if之后的语句一，否则执行else之后的语句二

if 条件:
    语句一
else:
    语句二

2. 多分支if-elif-else
   if为真执行if之后语句，if为假判断elif的条件，如果为真，执行elif之后的语句，否则执行else之后的语句

if 条件一:
    语句一
elif 条件二：
    语句二
else:
    语句三

2. 分支结构嵌套
   分支结构里面嵌套分支条件，从外向内，依次判断
   下图先判断条件一是否为真，如果为真执行语句一，否则执行语句四。执行完语句一判断条件二，如果条件二为真执行语句二，否则执行语句三

if 条件一:
    语句一
    if 条件二：
        语句二
    else:
        语句三
else:
    语句四

2. 循环结构：

1. for循环

for x in range(5):
    print(x)

运行结果：

2. while循环 <-> 逻辑运算、比较运算、布尔值
   while 判断条件(条件)：如果条件为真，循环执行，如果为假，退出循环

i = 0
while i < 5:
    print(i)
    i = i + 1

运行结果：

2. while True 无限循环 <-> 布尔值
   while True：会无限循环

i = 0
while 1:
    print(i)
    i = i + 1

运行结果：

2. break和continue 
   break语句直接跳出循环
   continue语句结束当前循环，执行下一次循环

i = 0
while 1:
    i = i + 1
    if i == 5:
        continue
    if i == 8:
        break
    print("此时i的值为：",i)

运行结果：

2. 循环结构嵌套
   循环体内嵌套其他循环体。外循环一次循环，内循环一次遍历

for i in range(4):
    print("此时i的值为：",i)
    for j in range(5):
        print("j的值为：",j)

运行结果：

1. 运算：

1. 算数运算

+ 表示求两数的和
- 表示求两数的差
* 表示求两数的乘积
/ 表示求两数的商
% 表示返回除法的余数
** 表示x的y次幂(x ** y)
// 表示求商的整数部分

x = 5
y = 2
print("x + y的结果为：",x + y)
print("x - y的结果为：",x - y)
print("x * y的结果为：",x * y)
print("x / y的结果为：",x / y)
print("x % y的结果为：",x % y)
print("x ** y的结果为：",x ** y)
print("x // y的结果为：",x // y)

运行结果：

2. 成员运算

in 序列中找到返回True，没找到返回False
not in 序列中没找到返回True，找到返回False

y = [1,2,3,4,5]
x = 2
z = 10
print("x in y的结果为：",x in y)
print("x not in y的结果为：",x not in y)
print("z in y的结果为：",z in y)
print("z not in y的结果为：",z not in y)

运行结果：

2. 比较运算

< 表示小于
<= 表示小于等于
>表示大于
>=表示大于等于
==表示等于
!=表示不等于

x = 1
y = 2
print("x < y的结果为：",x < y)
print("x <= y的结果为：",x <= y)
print("x > y的结果为：",x > y)
print("x >= y的结果为：",x >= y)
print("x == y的结果为：",x == y)
print("x != y的结果为：",x != y)

运行结果：

2. 赋值运算

= 简单赋值
+= 加法赋值，c += a相当于c = c + a
-= 减法赋值，c -= a相当于c = c - a
*= 乘法赋值，c *= a相当于c = c * a
/= 除法赋值，c /= a相当于c = c / a
%= 取模赋值，c %= a相当于c = c % a
**= 幂赋值，c **= a相当于c = c ** a
//= 取整赋值，c //= a相当于c = c // a

x = 1
y = 2
print("x的值为：",x)
print("y的值为：",y)
x += y
print("x += y的结果为:",x)
x = 1
y = 2
x -= y
print("x -= y的结果为：",x)
x = 1
y = 2
x *= y
print("x *= y的结果为：",x)
x = 1
y = 2
x /= y
print("x /= y的结果为：",x)
x = 1
y = 2
x %= y
print("x %= y的结果为：",x)
x = 1
y = 2
x **= y
print("x **= y的结果为：",x)
x = 1
y = 2
x //= y
print("x //= y的结果为：",x)

运行结果：

2. 逻辑运算

x and y 表示只有x和y都为真时，表达式才为真，其余为假
x or y表示 x和y都为假时表达式为假，其余为真
not x表示 x为真时，表达式为假，x为假时，表达式为真

2. 运算符优先级
   

1. 常见代码结构？

1. 函数：

1. 内置函数
   print()、Input()等

2. 自定义函数: <-> 全局变量与局部变量
1. 函数定义
   def 函数名 (参数)：
   函数内容
   return 表达式

2. 函数创建
   定义函数即为创建函数
3. 函数参数 
   函数名后圆括号里面等即为函数参数，也称为形参，实际调用时的参数为实参

2. 函数返回值
   return语句后跟着的表达式是函数返回值

2. 函数调用
   函数调用时只需要使用函数名即可调用

1. 模块：

1. 模块导入

基本形式：from 模块名 import *

2. random模块
   from random import *导入随机数模块
   random.random()生成一个0到1的随机浮点数
   random.randint(a,b)生成从a到b范围内的整数，包含端点

2. turtle模块
   from turtle import *
   Screen().bgpic("H2021/1.png") 设置背景图片
   t = Turtle() 设置画笔
   t.shape("turtle") 设置画笔的形状
   

2. time模块

2. OS模块
3. numpy模块

2. pandas模块

2. pyecharts模块

2. ieba模块
3. PIL库
4. tkinter库