1，执行整除运算//
4//3 —>1，整除的重点在于向下圆整，-10 // 3 向下圆整得到 -4，而不是-3
2，求余（求模）运算符%
x % y 等价于 x - ((x // y) * y)
3，乘方（求幂）运算符**
4，十六进制0x开头，八进制0开头，二进制0b开头
| 0xAF | 010 | 0b1011010010 |
|---|---|---|
| 175 | 8 | 722 |
5，变量variable，表示特定值的名称；使用python变量前必须对其赋值，python变量没有默认值！！！
6，python命名只能由字母、数字和下划线组成，且不能以数字开头
7，获取用户输入input，input("please input your name:")
x = input("x:")
y = input("y")
print(int(x) * int(y))
time = input("please input miin")
if int(time) % 60 == 0:print('hours!')
8，函数
内置函数pow 等价于 乘方运算符（ ** ）
| 2 ** 3 | pow(2,3) |
|---|---|
| 8 | 8 |
计算绝对值abs
将浮点数圆整为与之最接近的整数round，若在相邻整数之间一样近的时候，圆整到偶数
| abs(-10) | 2 // 3 | round(2 / 3) |
|---|---|---|
| 10 | 0 | 1.0 |
可将模块视为扩展，通过将其导入可以拓展Python的功能
使用import进行导入模块，再以module.function的方式使用模块的函数
import math math.floor(32.9)##floor向下圆整，结果为32 math.ceil(32.3)##ceil返回大于或等于给定数的最小整数，结果为33 math.ceil(32)##结果为32
对于圆整的概念，我是将数从上到下依次递减理解的
5
4
3
2
1.9
1
0
-0.4
-1
-2
1.9向下圆整就是，向下走，1.9介于2和1之间，向下走，当然就是1了
同样的道理，-0.4向上圆整就是向上走，-0.4介于0和-1之间，向下走当然就是0了
当然也可以直接从库里面调用某个函数
from math import sqrt sqrt(9)##平方根函数，结果为3.0
也可以使用变量来引用函数
from math import sqrt yanyu = sqrt yanyu(4)##结果为2.0专门处理复数的模块cmath
sqrt只能计算非负数的平方根，若使用其计算负数，则会报错
负数的平方根为虚数，而由实部和虚部组成的数为复数，1j是个虚数，虚数都是以j（或J）结尾。-1的平方根是1j
import cmath cmath.sqrt(-1)##结果为1j (1+3j) * (9+4j)##结果为(-3 + 31j)
有趣的海龟绘图法
from turtle import * ##最终的效果是绘制一个三角形 forward(100) left(120) forward(100) left(120) forward(100)
注释就不多说了吧， # 即可
python中的单引号和双引号实则都是对字符串的输出
主要区别就在于
let's go to school 此时就不能再使用单引号了，需要使用双引号 当然也可以来对单引号进行转移操作，让python明白引号之间的是字符串的一部分，而不是字符串的结束标志 let's go to school' #结果为：let's go to school "hello beyond" #结果为："hello beyond"
字符串的拼接
"hello, " + "beyond!" #结果为：hello,beyond x = "hello," y = 'beyond' x + y #结果为：hello,beyond
字符串表示str和repr
"Hello, world!" #结果为：'Hello, world!'
print("Hello, world!") #结果为：Hello, world!
"Hello,nworld!" #结果为：'Hello,nworld!'
print("Hello,nworld!")
"""
结果为：
Hello,
world!
"""
#使用str能以合理的方式将值转换为用户能够看懂的字符串
#使用repr时，通常会获得值的合法Python表达式表示
print(repr("Hello,nworld!")) #结果为：'Hello,nworld!'
print(str("Hello,nworld!"))
"""
结果为：
Hello,
world!
"""
要表示很长的字符串（跨行）时，使用三个单引号或三个双引号来表示
print("""there is a very
long
word
""")
输出结果：
there is avery
long
word
#常规字符串也可横跨多行。只要在行尾加上反斜杠，反斜杠和换行符将被转义，即被忽略
1+2+3+
4+5
#结果：15
原始字符串用前缀r表示，即原样输出即使带有转义字符也没啥卵用
原始字符串不能以单个反斜杠结尾
print(r'Let's go!') #结果为：Let's go! print(r'C:beyondzhendeainihaikuotiankongxihuanni') #结果为：C:beyondzhendeainihaikuotiankongxihuanni print(r"This is illegal")#结果为：编译器会报错，原因为原始字符串不能以单个反斜杠结尾 print(r“This is illegal” '\')#结果为：This is illegal
源代码也将被编码，且默认使用的也是UTF-8编码。
如果你想使用其他编码（例如，如果你使用的文本编辑器使用其他编码来存储源代码），可使用特殊的注释来指定。# -*- coding: encoding name -*-
请将其中的encoding name替换为你要使用的编码（大小写都行），如utf-8或latin-1
Python还提供了bytearray，它是bytes的可变版。从某种意义上说，它就像是可修改
的字符串——常规字符串是不能修改的
要替换其中的字符，必须将其指定为0～255的值。要插入字符，必须使用ord获取其序数值（ordinal value）
x = bytearray(b"Hello!") #b代表二进制，H为第0位，e为第1位 x[1] = ord(b"u") #将u代替e x #输出 结果：bytearray(b'Hullo!')常用函数
| 函 数（方括号内的参数是可选的） | 描 述 |
|---|---|
| abs(number) | 返回指定数的绝对值 |
| bytes(string, encoding[, errors]) | 对指定的字符串进行编码，并以指定的方式处理错误 |
| cmath.sqrt(number) | 返回平方根；可用于负数 |
| float(object) | 将字符串或数字转换为浮点数 |
| help([object]) | 提供交互式帮助 |
| input(prompt) | 以字符串的方式获取用户输入 |
| int(object) | 将字符串或数转换为整数 |
| math.ceil(number) | 以浮点数的方式返回向上圆整的结果 |
| math.floor(number) | 以浮点数的方式返回向下圆整的结果 |
| math.sqrt(number) | 返回平方根；不能用于负数 |
| pow(x, y[, z]) | 返回x的y次方对z求模的结果 |
| print(object, …) | 将提供的实参打印出来，并用空格分隔 |
| repr(object) | 返回指定值的字符串表示 |
| round(number[, ndigits]) | 四舍五入为指定的精度，正好为5时舍入到偶数 |
| str(object) | 将指定的值转换为字符串。用于转换bytes时，可指定编码和错误处理方式 |
在Python中，最基本的数据结构为序列（包括列表、元组、字符串等）（sequence）
列表是可以修改的，而元组不可以
Python支持一种数据结构的基本概念，名为容器（container）
容器基本上就是可包含其他对象的对象
两种主要的容器是序列（如列表和元组）和映射（如字典）
在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。
有一种既不是序列也不是映射的容器，它就是集合（set）
1，索引
索引中，下标从0开始访问单个元素，0时第一个元素的位置
用负数索引时，Python将从右（即从最后一个元素）开始往左数，-1是最后一个元素的位置
beyond = "I love the band"
beyond[0]#结果为：I
beyond[2]#结果为：l
beyond[-1]#结果为：d
beyond[-2]#结果为：n
"beyond"[2]#结果为：y
fourth = input('Year: ')[3]
输入结果：Year: 1999
输出结果：'9'
2，切片:
除使用索引来访问单个元素外，还可使用切片（slicing）来访问特定范围内的元素
简而言之，左闭右开
切片索引方向只能从左向右，不能反过来操作，即左小右大，左闭右开
若要反过来操作需要指定步长即可
number = [0,1,2,3,4,5,6,7,8,9] number[1:3]#结果为：[1，2] number[4:5]#结果为：[4] number[8:10]#结果为：[8,9] 索引10，该元素压根不存在，但是没有报错，压根用不到，左闭右开 number[-3:-1]#结果为：[7,8] number[-1:-3]#结果为：[] ''' 如果第一个索引指定的元素位于第二个索引指定的元素后面 （在这里，倒数第3个元素位于第1个元素后面），结果就为空序列 ''' #切片结束于序列末尾，可省略第二个索引 number[-3:]#结果为：[7,8,9] #如果切片始于序列开头，可省略第一个索引 number[:3]#结果为：[0,1,2] #要复制整个序列，可将两个索引都省略 number[:]#结果为：[0,1,2,3,4,5,6,7,8,9]设置步长的切片
通常情况不写步长的时候，步长默认为1
number=[0,1,2,3,4,5,6,7,8,9] number[0:5]#结果为：[0,1,2,3,4] number[0:5:1]#结果为：[0,1,2,3,4] #不写第三个参数步长的话默认为1 number[0:10:2]#结果为：[0,2,4,6,8] 步长为2时，将从起点和终点之间每隔一个元素提取一个元素 #要从序列中每隔3个元素提取1个，只需提供步长4即可 number[::4]#结果为：[0,4,8] #当然，步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素 number[8:3:-1]#结果为：[8,7,6,5,4] number[3:8:-1]#结果为：[] #步长为正数时，它从起点移到终点 #步长为负数时，它从终点移到起点 number[5::-2]#结果为：[5,3,1] number[:5:-2]#结果为：[9,7]3，序列相加+
[1,2,3] + [3,2,1]#结果为：[1,2,3,3,2,1] 'hello,' + "beyond"#结果为：'hello,beyond' [1,2,2] + "yanyu"#结果为：报错！！！ #一般而言，不能拼接不同类型的序列4，乘法*
“beyond” * 5#结果为：'beyondbeyondbeyondbeyondbeyond' [521] * 3#结果为：[521,521,521] ''' Python中None表示什么都没有，为空 将列表长度初始化为5如下： ''' beyond = [None] * 5 beyond#结果为：[None,None,None,None,None]5，成员资格in
要检查特定的值（可以是单个字符也可以是字符串）是否包含在序列中，可使用运算符in
它检查是否满足指定的条件，并返回相应的值，满足时返回True，不满足时返回False
这样的运算符称为布尔运算符，而前述真值称为布尔值
beyond = "yanyu like beyond"
'y' in beyond#结果为：True
'q' in beyond#结果为：False
users = ['yanyu','huangjiaju','yeshirong']
input('Enter your user name:') in users
Enter your user name:yanyu
#结果为：True
长度、最小值、最大值
函数len返回序列包含的元素个数，min和max分别返回序列中最小和最大的元素
beyond = [19,5,22] len(beyond)#结果为：3 max(beyond)#结果为：22 min(beyond)#结果为：5 max(1999,2005)#结果为：2005 min(98,55)#结果为：55函数list，使用字符串来创建列表
可将任何序列（而不仅仅是字符串）作为list的参数
list("beyond")#结果为：['b', 'e', 'y', 'o', 'n', 'd']
基本的列表操作包括索引、切片、拼接和相乘，但列表的有趣之处在于它
是可以修改的
1， 修改列表：给元素赋值
beyond = [1,2,3,4,5] beyond[1] = 99 beyond#结果为：[1,99,3,4,5] #不能给不存在的元素赋值，因此如果列表的长度为2，就不能给索引为100的元素赋值
2，删除元素del
yanyu = ["yanyu",1999,'huangjiaju'] del yanyu[1] yanyu#结果为：['yanyu','huangjiaju']
3，给切片赋值
yanyu = list("beyond")
yanyu#结果为：['b', 'e', 'y', 'o', 'n', 'd']
yanyu[2:] = list('SQ')
yanyu#结果为：['b','e','S','Q']
yanyu[3:] = list("jiaju")
yanyu#结果为：['b', 'e', 'S', 'j', 'i', 'a', 'j', 'u']
＃在不替换原有元素的情况下插入新元素
yanyu[1:1] = [6,7,8]
yanyu#结果为：['b', 6, 7, 8, 'e', 'S', 'j', 'i', 'a', 'j', 'u']
yanyu[1:3] = []
yanyu#结果为：['b', 8, 'e', 'S', 'j', 'i', 'a', 'j', 'u']
'''
这很显然与del yanyu[1:3]等效
类推，也可以对执行步长不为1的切片进行赋值
'''
4，列表方法
方法是与对象（列表、数、字符串等）联系紧密的函数
object.method(arguments)
方法调用与函数调用很像，只是在方法名前加上了对象和句点
列表包含多个可用来查看或修改其内容的方法
append，将一个对象附加到列表末尾
yanyu = [1,2,4,5,6] yanyu.append(7) yanyu#结果为：[1,2,4,5,6,7]
clear，就地清空列表的内容
yanyu = [1,2,3] yanyu.clear() yanyu#结果为：[] #这类似于切片赋值语句yanyu[:] = []
copy，复制列表（将另一个名称关联到列表）
a = [1,2,3] b = a b[1] = 4 a#结果为：[1,4,3] #将另一个名称关联到列表 a = [1,2,3] b = a.copy() b[1] = 4 a#结果为：[1, 2, 3] #这类似于使用a[:]或list(a)，它们也都复制a
count，计算指定的元素在列表中出现了多少次
['to', 'be', 'or', 'not', 'to', 'be'].count('to') #结果为：2
x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
x.count(1) #结果为：2
x.count([1, 2]) #结果为：1
extend，同时将多个值附加到列表末尾，可使用一个列表来扩展另一个列表
a = [1, 2, 3] b = [4, 5, 6] a.extend(b) a #结果为：[1, 2, 3, 4, 5, 6] #很明显a这个列表已经发生了修改 ''' extend是将b扩展到a，a会发生变化会被扩展 而常规拼接+，只是返回一个新的序列，原本的不会被修改 ''' a = [1, 2, 3] b = [4, 5, 6] a + b #结果为：[1, 2, 3, 4, 5, 6] a #结果为：[1, 2, 3] #很明显a这个列表并没有改变 a = a+b#结果为：[1, 2, 3, 4, 5, 6] 效果实现了 但是拼接的效率将比extend低 a = [1, 2, 3] b = [4, 5, 6] a[len(a):] = b a #结果为：[1, 2, 3, 4, 5, 6] #这虽然可行，但可读性不是很高
index，查找指定值第一次出现的索引
yanyu= ['We', 'are', 'the', 'knights', 'who', 'say', 'huangjiaju']
yanyu.index('who') #结果为：4 who处于索引第4处
yanyu.index('xixihaha')#结果为：报错 其不存在
insert，用于将一个对象插入列表
numbers = [1, 2, 3, 5, 6, 7] numbers.insert(3, 'four') numbers #结果为：[1, 2, 3, 'four', 5, 6, 7] ''' 与extend一样，也可使用切片赋值来获得与insert一样的效果 这虽巧妙，但可读性根本无法与使用insert媲美 ''' numbers = [1, 2, 3, 5, 6, 7] numbers[3:3] = ['four'] numbers #结果为：[1, 2, 3, 'four', 5, 6, 7]
pop，从列表中删除一个元素（末尾为最后一个元素），并返回这一元素
pop是唯一既修改列表又返回一个非None值的列表方法
x = [1,2,3，9，8，7] x.pop()#结果为：7 x#结果为：[1,2,3,9,8] x.pop(2)#结果为：3 x#结果为：[1,2,9,8]
''' 使用pop可实现一种常见的数据结构——栈（stack）后进先出 push和pop是大家普遍接受的两种栈操作（加入和取走）的名称 Python没有提供push，但可使用append来替代 方法pop和append的效果相反，因此将刚弹出的值压入（或附加）后，得到的栈将与原来相同 要创建先进先出（FIFO）的队列，可使用insert(0, ...)代替append 另外，也可继续使用append，但用pop(0)替代pop()。 ''' x = [1,4,7] x.append(x.pop()) x#结果为：[1,4,7]
remove，用于删除第一个为指定值的元素。
remove是就地修改且不返回值的方法
不同于pop的是，它修改列表，但不返回任何值
x = ['I','love',"beyond",'and',"I",'hahaha']
x.remove("I")
x#结果为：
x.remove("SQ")#结果为：报错 原因为列表里面没有该元素
reverse，按相反的顺序排列列表中的元素
修改列表，但不返回任何值（与remove和sort等方法一样）
x = [1, 2, 3] x.reverse() x #结果为：[3, 2, 1] ''' 如果要按相反的顺序迭代序列，可使用函数reversed 这个函数不返回列表，而是返回一个迭代器，不改变原来的列表 ''' x = [1, 2, 3] list(reversed(x)) #结果为：[3, 2, 1] x#结果为：[1,2,3]
sort，用于对列表就地排序
sort方法：对原来的列表进行修改，使其元素按顺序排列，且不返回任何值！！！
sorted函数：可用于任何序列，但总是返回一个列表
x = [7,4,1,8,9,6,5,2,3]
x.sort()
x#结果为：[1,2,3,4,5,6,7,8,9]
y = [9,5,1,7,8,6]
z = y.sort()
print(z)#结果为：None 其原因在于，sort不返回任何值！！！
y#结果为：[1,5,6,7,8,9] y列表排序了，但是sort不返回任何值导致z为None
#先将z关联到y的副本，再对z进行排序
y = [9,5,1,7,8,6]
z = y.copy()
z.sort()
z#结果为：[1, 5, 6, 7, 8, 9] z进行排序
y#结果为：[9, 5, 1, 7, 8, 6] y并未修改
#另一种方式是使用函数sorted
x = [4, 6, 2, 1, 7, 9]
y = sorted(x)
y #结果为：[1, 2, 4, 6, 7, 9]
x #结果为：[4, 6, 2, 1, 7, 9]
#如果要将元素按相反的顺序排列，可先使用sort（或sorted），再调用方法reverse，也可使用参数reverse
sorted('Python') #结果为：['P', 'h', 'n', 'o', 't', 'y'] 大写字母<小写字母，相同类型字母a或A最小
高级排序
方法sort接受两个可选参数（关键字参数）：key和reverse
参数key类似于参数cmp：你将其设置为一个用于排序的函数
参数reverse：只需将其指定为一个真值（True或False），以指出是否要按相反的顺序对列表进行排序
要根据长度对元素进行排序，可将参数key设置为函数len
x = ["qwert","asf",'zx',"vxcb",'sdfsd'] x.sort(key=len) x#结果为：['zx', 'asf', 'vxcb', 'qwert', 'sdfsd'] y = [4,6,8,2,1,9,7] y.sort(reverse=True) y#结果为：[9, 8, 7, 6, 4, 2, 1]元组：不可修改的序列()
元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组
1,2,3#结果为：(1, 2, 3) 元组 (1,2,3)#结果为：(1, 2, 3) 元组 #逗号很关键，若只有一个数时，不加逗号就代表数，加上逗号代表元组 1999#结果为：1999 数 1999,#结果为：(1999,) 元组 (1999,)#结果为：(1999,) 元组
函数tuple的工作原理与list很像：它将一个序列作为参数，并将其转换为元组
如果参数已经是元组，就原封不动地返回它
tuple([1, 2, 3])#结果为：(1, 2, 3)
tuple('abc')#结果为：('a', 'b', 'c')
tuple((1, 2, 3))#结果为：(1, 2, 3)
元组的创建及其元素的访问方式与其他序列相同
x = 1, 2, 3 x#结果为：(1,2,3) x[1]#结果为：2 x[0:2] #结果为：(1, 2)
常用函数
| 函 数 | 描 述 |
|---|---|
| len(seq) | 返回序列的长度 |
| list(seq) | 将序列转换为列表 |
| max(args) | 返回序列或一组参数中的最大值 |
| min(args) | 返回序列和一组参数中的最小值 |
| reversed(seq) | 让你能够反向迭代序列 |
| sorted(seq) | 返回一个有序列表，其中包含指定序列中的所有元素 |
| tuple(seq) | 将序列转换为元组 |
