python math库约分 python约等于

第一至二章

主要介绍python的概况、安装，此处略过

第三章 小试Python

1.数字

Python的数字类型主要分为 整数 int 、浮点数 float 以及 复数 complex 、定点数 decimal 、 分数 fraction等

注意：

'/'  除法运算符 返回 浮点数
>>>7/2
3.5
'//'  整除运算符 返回 整数
>>>7//2
3
'**'  指数运算符
>>>2**4
16

使用 == 比较 比较是否值相等(不管类型)；使用===比较，比较类型以及值是否相等

所有数字类型(除复数)均支持以下运算

按优先级升序排列

2.字符串

字符串用 '' (单引号)或 ""(双引号)括起来

使用 \ (反斜线)来对特殊字符转义

>>> print("C:\windows\name")
C:\windows
ame
>>> print(r"C:\windows\name")
C:\windows\name

此处路径上的 \n 被转义，可以在字符串引号前加上 r

'''内容''' (三个单引号) 或者 """内容""" (三个双引号) 来表示多行字符串

每行结尾会被自动加上换行符，也可以加入 \ 来避免输出换行符

print("""
How are you?
I'm fine.""")

O:

How are you?
I'm fine.

print("""\
How are you?
I'm fine.""")

O:
How are you?
I'm fine.

字符串可以用 + 来连接，用* 来重复，有两个或多个相邻，结束其会自动合并

利用 索引 的方式访问字符串中某个字符的位置（若为负数则从右往左，-0和0都表示第一个字符，倒序从下表的-1开始计算）

索引的使用：

>>> word = 'Python'
>>> word[-1]
'n'

切片的使用：

>>> word = 'Python'
>>> word[0:2]
'Py'

word[a:b] 从a开始取，到b结束(不包括b) 省略a则 默认从0开始，省略 吧，则默认取到最后

切片工作原理：将索引视作字符间的指向，最左边边界为0，n个字符 最右边为n，取两边界间的字符

+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0   1   2   3   4   5   6
   -6  -5  -4  -3  -2  -1

切片不改变原字符串

简单的字符串函数

word = "Hello World"
print("执行replace前:" + word)
print("word的字符数为" + str(len(word)))
word = word.replace("World","Python")
print("执行replace后:" + word)

O:
执行replace前:Hello World
word的字符数为11
执行replace后:Hello Python

len(字符串名) 返回字符串个数

replace(a,b,[c]) 将 字符串a 替换成 字符串b，[c]为可选参数，表示替换的最大次数

3.布尔类型

只有两个值： True 和 False

4.字面量与常量

字面量即 字面变量 ，命名规则：变量名由 字符，数字，_ 组成，不能以数字开头

常量 ，不能改变常量的值，Python语法上没有定义常量，但大多数语言常常使用全大写的变量名来表示常量

所以一般约定：如果名字全是大写的变量就不要去修改

5.表达式

表达式可以理解为“任何有值的东西”

name=language='Python'

此处为一行，但是有两个表达式

表达式的赋值顺序是从右往左，一般一行只写一个表达式(可读性高)

所以上面语句可以分成

language='Python'
name=language

6.注释

单行注释用 # ： 一行内 #后的内容程序不会将其当成代码运行(一般写在开头或者说首行)

多行注释用三个单引号或双引号

'''
使用三个单引号分别作为注释的开头和结尾
可以一次性注释多行内容
在里面的内容全为注释
'''

"""
使用三个双引号分别作为注释的开头和结尾
可以一次性注释多行内容
在里面的内容全为注释
"""

关键字in和is

in 判断是否包含在指定序列中

is判断两个标识符是否引用于同一个对象

>>> 5 in (1,2,5,8,10)
True

>>> a = 20
>>> b = 20
>>> a is b
True

第四章 数据结构

python大部分序列都可以进行通用操作，包括索引、切片、相同类型序列相加、乘法、成员资格、长度、最大值和最小值

1.序列

三种基本序列类型(她们都是序列)：

列表：	[1,2,3,4]
元组：	(1,2,3,4)
字符串："1234" 或 '1234'

索引语法：变量名[元素编号]

从左至右 0~n-1

从右往左 -1~-n (最右边为-1)

切片语法：变量名[a:b:c] a为开始位置(默认为0)，b为结束位置(默认取到最后一位)

c为可选参数，表示步长(默认为1，不支持0，负数从右往左取)

[ValueError: slice step cannot be zero 报错：步长为0]

步长为正：开始点必须小于结束点 步长为负：开始点必须大于结束点

x1 = [1,2,3,4,5]
print(x1[1:4])
print(x1[1:4:2])

O:
[2, 3, 4]
[2, 4]

序列操作演示

#序列相加(要相同的序列类型哦 '+'号相连)
x1 = [0,1,2,3]+[4,5,6]
print("列表：",x1)
x2 = "Hello "+"World!"
print("字符串",x2)

O:
列表： [0, 1, 2, 3, 4, 5, 6]
字符串 Hello World!


x1 = [2233]*5
print("列表:：",x1)
x2 = "冲！"*3
print("字符串:",x2)
x3 = [2233]*0
print("列表:：",x3)
x4 = "冲！"*0
print("字符串:",x4)

O:
列表:： [2233, 2233, 2233, 2233, 2233]
字符串: 冲！冲！冲！
列表:： []
字符串: 


#成员资格(判断元素是否在序列中)A in B 判断左侧的A是否在右侧的B中,且只有元素类型和值完全一致才算包含'==='
x1 = [0,1,2,3]
print("列表:",0 in x1)
print("列表:",8 in x1)
x2 = "你好World123"
print("字符串:","你好" in x2)
print("字符串:","好o" in x2)
#错误:   	print(123 in x2)     

O:
列表: True
列表: False
字符串: True
字符串: False
#错误:  	TypeError: 'in <string>' requires string as left operand, not int
#123是int 而 "123"是string

#长度、最小值、最大值、求和  (len和sum只能接受一个序列,字符串用'+'连接,字符串用ASCII码作比较)
x1 = [0,1,2,3]
print("列表x1:",x1)
print("列表长度:",len(x1))
print("列表最大值:",max(x1))
print("列表最小值:",min(x1))
print("列表求和:",sum(x1))

x1 = [0,1,2,3]
x2 = [7,8,9]
print("列表x1:",x1,"  x2:",x2)
print("俩列表最大值:",max(x1,x2))
print("俩列表最小值:",min(x1,x2))

x3 = "Hello word!"
print("字符串x1:"+x3)
print("字符串长度:",len(x3))
print("字符串最大值:",max(x3))
print("字符串最小值:",min(x3))

x3 = "Hello word!"
x4 = "Hello China!"
print("字符串x3:"+x3+"  x4:"+x4)
print("俩字符串最大值:",max(x3,x4))
print("俩字符串最小值:",min(x3,x4))

O:
列表x1: [0, 1, 2, 3]
列表长度: 4
列表最大值: 3
列表最小值: 0
列表求和: 6
列表x1: [0, 1, 2, 3]   x2: [7, 8, 9]
俩列表最大值: [7, 8, 9]
俩表最小值: [0, 1, 2, 3]
字符串x1:Hello word!
字符串长度: 11
字符串最大值: w
字符串最小值:  
字符串x3:Hello word!  x4:Hello China!
俩字符串最大值: Hello word!
俩字符串最小值: Hello China!

2.列表

列表可以存储不同类型的数据，可用通过索引 获取 或 更新 其中内容 ，且前后类型可以不一致

x1 = [0,1,"Hello",[2,3]]
print(x1[3])
x1[3] = "world"
print(x1[3])

O:
[2, 3]
world

2.1)增加元素

append(元素) 函数

往后增加一个 元素

#3是一个元素，类型为int
x1 = [0,1,2]
x1.append(3)
print(x1)

O:
[0, 1, 2, 3]


#[3]是一个元素，类型为列表且只有一个数据
x1 = [0,1,2]
x1.append([3])
print(x1)

O:
[0, 1, 2, [3]]


#[3,4] 是一个元素 类型为列表
x1 = [0,1,2]
x1.append([3,4])	
print(x1)
   
O:
[0, 1, 2, [3, 4]]

extend(列表) 函数

往后增加多个元素 A.extend(B) 即 把B列表的数据加入到A列表后面

#[3]是一个列表
x1 = [0,1,2]
x1.extend([3])
print(x1)

O:
[0, 1, 2, 3]


#[3,4]是一个列表
x1 = [0,1,2]
x1.extend([3,4])
print(x1)

O:
[0, 1, 2, 3, 4]


#[[3],[4]]是一个列表，由两个列表组成
x1 = [0,1,2]
x1.extend([[3],[4]])
print(x1)

O:
[0, 1, 2, [3], [4]]

insert(索引,元素) 函数

任意位置 插入(一个)元素

x1 = [0,1,2]
x1.insert(0,9)
print(x1)

O:
[9, 0, 1, 2]



#超出索引值会加在最后一位
x1 = [0,1,2]
x1.insert(10,9)
print(x1)


#索引值为(绝对值不超过索引值的)负数，放在从右往左第 (输入的)索引值加一个 位置
x1 = [0,1,2]
x1.insert(-1,9)
print(x1)

O:
[0, 1, 9, 2]

#索引值为(绝对值超过索引值)的负数与索引值为正负零相同，均放在最前面
x1 = [0,1,2]
x1.insert(-10,9)
print(x1)

O:
[9, 0, 1, 2]

x1 = [0,1,2]
x1.insert(-0,9)
print(x1)

O:
[9, 0, 1, 2]

2.2)删除元素

pop(索引) 函数

根据索引删除列表中的一个元素(默认为最后一个)，并把 该元素 作为返回值

x1 = [4,5,2,1]
print(x1.pop())
print(x1)

O:
1
[4, 5, 2]

x1 = [4,5,2,1]
print(x1.pop(1))
print(x1)

O:
5
[4, 2, 1]

remove(元素) 函数

接收一个元素(元素必须存在,否则报错)，根据内容删除元素 ，只会删除查找到的第一个元素，无返回值

x1 = [5,6,7,8]
print(x1.remove(6))
print(x1)

O:
None
[5, 7, 8]


#当remove中的内容不存在与列表中时
#ValueError: list.remove(x): x not in list

del 关键字

del 后面指定 列表元素和索引

x1 = [0,4,5,6]
del x1[2]
print(x1)


O:
[0, 4, 6]

2.3) 其他操作

1. reverse 可以反转列表 和 [::-1]类似，但reverse修改的是原来的列表，并且 无返回值

x1 = [0,1,2,3]
print(x1.reverse())
print(x1)


O:
None
[3, 2, 1, 0]

2. count 统计某元素在列表中出现的次数

x1 = [0,1,2,2,2,3]
print(x1.count(2))

O:
3

3. sort对列表进行排序，可自定义排序方式。sort会修改并对源列表排序，无返回值

x1 = [3,4,1,5,6,2]
x1.sort()
print(x1)

O:
[1, 2, 3, 4, 5, 6]

3.元组

元组与列表相似，但是元组创建后不能修改，不能删除单个元素，可以整个删除

因为元组不能修改，所以查询速度更快

3.1）定义元组

type(A) 可以判断A的类型

#最后一个元素后的逗号可加可不加，但只有一个元素是必须加
x1 = (1,2,3)
x2 = (0,)
print(type(x1))
print(type(x2))

O:
<class 'tuple'>
<class 'tuple'>

3.2）删除元组

del 关键字

x1 = (1,2,3)
del x1
print(x1)

O:
NameError: name 'x1' is not defined

3.3)其他操作

1. count 统计元素在元组中出现过的次数
2. index 查找元素在元组中的位置

x1 = (1,"hello","world")
print(x1[1],"index is ",x1.index("hello"))

O:
hello index is  1

4.字典

字典类型可以像字典一样查找 ,（如PHP中的Array，Java中的HashMap）

键值对应(key:value)

1定义字典

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
}

print(type(dog))
print(dog)

O:
<class 'dict'>
{'name': 'kk', 'color': 'white', 'action': 'run'}


#定义一个空字典
empty = {}
print(type(empty))
print(empty)

O:
<class 'dict'>
{}

2)使用字典

字典是一组 键值对，用 键 去访问 值

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
}

print(dog["name"],"is ",dog["color"])

O:
kk is  white


dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
}

dog["name"] = "aa"
print(dog["name"],"is ",dog["color"])

O:
aa is  white

新增元素和修改元素语法一样

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
}

dog["animal"] = "dog"
print(dog)

O:
{'name': 'kk', 'color': 'white', 'action': 'run', 'animal': 'dog'}

删除使用 del 关键字

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
}

dog["animal"] = "dog"
del dog["action"]
print(dog)
del dog
print(dog)

O:
{'name': 'kk', 'color': 'white', 'animal': 'dog'}
NameError: name 'dog' is not defined

3)其他操作

1. clear() 清空字典

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
}
dog.clear()
print(dog)

O:
{}

1. copy() 返回一个相同的新字典(拷贝一份新副本)

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
    "animal":"dog",
}
cat = dog
qwq = dog.copy()
print("原值")
print("dog:",dog)
print("cat:",cat)
print("qwq:",qwq)

print("改动")
cat["animal"] = "cat"
qwq["qwq"] = "Coding"
print("dog:",dog)
print("cat:",cat)
print("qwq:",qwq)

#直接赋值类似公用一个地址，改变会影响其他值，而copy是全新的独立的字典
O:
原值
dog: {'name': 'kk', 'color': 'white', 'action': 'run', 'animal': 'dog'}
cat: {'name': 'kk', 'color': 'white', 'action': 'run', 'animal': 'dog'}
qwq: {'name': 'kk', 'color': 'white', 'action': 'run', 'animal': 'dog'}
改动
dog: {'name': 'kk', 'color': 'white', 'action': 'run', 'animal': 'cat'}
cat: {'name': 'kk', 'color': 'white', 'action': 'run', 'animal': 'cat'}
qwq: {'name': 'kk', 'color': 'white', 'action': 'run', 'animal': 'dog', 'qwq': 'Coding'}

1. fromkeys() 创建一个新字典，用序列中的元素作为键，第二个参数为所有参数对应的初始值

x1 = ["name","age","class"]
x2 = ["kk",15,0]
print("默认：",dict.fromkeys(x1))
print("不默认：",dict.fromkeys(x1,x2))

O:
默认： {'name': None, 'age': None, 'class': None}
不默认： {'name': ['kk', 15, 0], 'age': ['kk', 15, 0], 'class': ['kk', 15, 0]}

1. get() 返回键对应的值，若不存在则返回默认值(用键值访问若不存在则会报错)

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
    "animal":"dog",
}
print("name:",dog.get("name"))
print("age:",dog.get("age"))
print("age:",dog.get("age",15))

O:
name: kk
age: None
age: 15

5. keys()返回一个包含字典所有键的列表 常常与 in 连用判断一个键是否在字典中

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
    "animal":"dog",
}
key = dog.keys()
print(key)
print("name" in key)
print("age" in key)

O:
dict_keys(['name', 'color', 'action', 'animal'])
True
False

6. values()返回一个包含所有值的列表

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
    "animal":"dog",
}
print(dog.values())

O:
dict_values(['kk', 'white', 'run', 'dog'])

7. items() 返回一个包含所有键值的列表(实际类型为<class 'dict_items'>)，因为字典无法直接遍历所以itmes常与 keys和values遍历字典

dog = {
    "name":"kk",
    "color":"white",
    "action":"run",
    "animal":"dog",
}
key = dog.keys()
value = dog.values()
print(dog.items())
for key,value in dog.items():
    print(key,"=>",value)
    
O:
dict_items([('name', 'kk'), ('color', 'white'), ('action', 'run'), ('animal', 'dog')])
name => kk
color => white
action => run
animal => dog

5.集合

集合类似列表，但集合不包含重复的值

1.定义集合

empty = set()       #若直接赋值{}，将会是空字典,定义空集合必须使用set函数
print(type(empty))

empty_dict = {}     #空字典
print(type(empty_dict))

x1 = {1,2,3,}       #大括号加元素，最后一个逗号可加可不加
print(type(x1))

x2 = set([1,"Hello",0.1])   #set(列表)
print(type(x2))


O:
<class 'set'>
<class 'dict'>
<class 'set'>
<class 'set'>


#过滤重复元素
x3 = {1,2,2,2,2}
print(x3)

O:
{1, 2}

2)添加元素

添加可用 add()函数 (只接受一个参数)添加新元素时，若以经存在则不进行添加，保证集合元素唯一性

x1 = {1,2,3}
x1.add(4)
print(x1)
x1.add(2)
print(x1)

O:
{1, 2, 3, 4}
{1, 2, 3, 4}

3)删除元素

删除可用remove()

x1 = {1,2,3,4}
x1.remove(4)
print(x1)

O:
{1, 2, 3}

6.推导式

1)列表推导式

语法：用中括号括起来，中间使用for语句，后面跟着if语句用作判断，满足条件的传到for语句前面用作构建的列表

x1 = [0,1,2,3,4,5,6]
x2 = [x for x in x1 if x%2 == 0 ]
print(x2)

O:
[0, 2, 4, 6]

列表推导式最擅长对整个列表分别做相同的操作，并返回得到一个新列表

2)字典推导式

和列表推导式类似。推导式定义时成对生成值对

x1 = {x:x**2 for x in range(5)}
print(x1)

x2 = {v:k for k,v in x1.items()}
print(x2)

x3 = {k:v**0.5 for k,v in x1.items()}
print(x3)

O:
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
{0: 0, 1: 1, 4: 2, 9: 3, 16: 4}
{0: 0.0, 1: 1.0, 2: 2.0, 3: 3.0, 4: 4.0}

3)集合推导式

和列表推导式一样，但会去除重复元素，且使用花括号

x1 = {x**2 for x in range(5)}
print(x1)
x2 = {x for x in x1 if x%2 == 1}
print(x2)

O:
{0, 1, 4, 9, 16}
{1, 9}

，保证集合元素唯一性

x1 = {1,2,3}
x1.add(4)
print(x1)
x1.add(2)
print(x1)

O:
{1, 2, 3, 4}
{1, 2, 3, 4}

3)删除元素

删除可用remove()

x1 = {1,2,3,4}
x1.remove(4)
print(x1)

O:
{1, 2, 3}

6.推导式

1)列表推导式

语法：用中括号括起来，中间使用for语句，后面跟着if语句用作判断，满足条件的传到for语句前面用作构建的列表

x1 = [0,1,2,3,4,5,6]
x2 = [x for x in x1 if x%2 == 0 ]
print(x2)

O:
[0, 2, 4, 6]

列表推导式最擅长对整个列表分别做相同的操作，并返回得到一个新列表

2)字典推导式

和列表推导式类似。推导式定义时成对生成值对

x1 = {x:x**2 for x in range(5)}
print(x1)

x2 = {v:k for k,v in x1.items()}
print(x2)

x3 = {k:v**0.5 for k,v in x1.items()}
print(x3)

O:
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
{0: 0, 1: 1, 4: 2, 9: 3, 16: 4}
{0: 0.0, 1: 1.0, 2: 2.0, 3: 3.0, 4: 4.0}

3)集合推导式

和列表推导式一样，但会去除重复元素，且使用花括号

x1 = {x**2 for x in range(5)}
print(x1)
x2 = {x for x in x1 if x%2 == 1}
print(x2)

O:
{0, 1, 4, 9, 16}
{1, 9}