目录
前言
第一周怀着小小的期待开始接触python，属于胡小楠的python学习之路开始啦，这里是一些零零散散的笔记qwq
学习方式：看菜鸟教程，摘录重点
一、基本数据类型
①Number（数字） ②String（字符串） ③Tuple（元组）
④List（列表） ⑤Set（集合） ⑥Dictionary（字典）
1. Number
包括int, float, bool（布尔型，True and False）, complex（复数）
※bool是int的子类
⑴ del：删除引用对象
⑵ 数值运算
>>> 5 + 4 # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7 # 乘法
21
>>> 2 / 4 # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32⑶ 复数
可以用a+bj，或者complex(a,b)表示，ab都是浮点型
(4) 数字函数
| 函数 | 返回值 |
|---|---|
| abs() | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| max(x1, x2,...) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1, x2,...) | 返回给定参数的最小值，参数可以为序列。 |
| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 |
| pow(x, y) | x**y 运算后的值。 |
| round(x [,n]) | 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。 |
| sqrt(x) | 返回数字x的平方根。 |
(5) 随机数函数
| 函数 | 描述 |
|---|---|
| random() | 随机生成下一个实数，它在[0,1)范围内。 |
| seed([x]) | 改变随机数生成器的种子seed。如果不了解其原理，不必特别去设定seed，Python会帮你选择seed。 |
| shuffle(lst) | 将序列的所有元素随机排序 |
| uniform(x, y) | 随机生成下一个实数，它在[x,y]范围内。 |
(6) 三角函数
| 函数 | 描述 |
|---|---|
| acos(x) | 返回x的反余弦弧度值。 |
| asin(x) | 返回x的反正弦弧度值。 |
| atan(x) | 返回x的反正切弧度值。 |
| atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值。 |
| cos(x) | 返回x的弧度的余弦值。 |
| hypot(x, y) | 返回欧几里德范数 sqrt(xx + yy)。 |
| sin(x) | 返回的x弧度的正弦值。 |
| tan(x) | 返回x弧度的正切值。 |
| degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0 |
| radians(x) | 将角度转换为弧度 |
2.String
⑴输出
str = 'helloworld'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串
⑵ r
反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
⑶ 样例
字符串有点类似数组
>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P(4) 转义字符
(4) 转义字符
| 转义字符 | 描述 | 实例 |
|---|---|---|
| \(在行尾时) | 续行符 | |
| \\ | 反斜杠符号 | |
| \' | 单引号 | |
| \" | 双引号 | |
| \a | 响铃 | 执行后电脑有响声 |
| \b | 退格(Backspace) | |
| \000 | 空 | |
| \n | 换行 | |
| \v | 纵向制表符 | |
| \t | 横向制表符 | |
| \r | 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 | |
| \f | 换页 | |
| \yyy | 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 | |
| \xyy | 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 | |
| \other | 其它的字符以普通格式输出 |
(5) format 格式化函数
(6) 三引号
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
(7) 内建函数
| 函数 | 方法 |
|---|---|
| len(string) | 返回字符串长度 |
| lower() | 转换字符串中所有大写字符为小写 |
| max(str) | 返回字符串 str 中最大的字母 |
| min(str) | 返回字符串 str 中最小的字母 |
3.List
(1) 修改
a = [1, 2, 3, 4, 5]
a[2:4] = [] #将三四位清除
print(a)
(2) 添加
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
(3) 删除
list = ['Google', 'Runoob', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
(4) 脚本操作符
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
(5) 嵌套列表
>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'
(6) 函数
| 函数 | 描述 |
|---|---|
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将元组转换为列表 |
4.Tuple
元素不能修改，只有一个元素时需要在元素后加逗号, 否则括号会被当作运算符使用
>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>(1) 访问元组
也类似于数组，可表示为tup[0] tup[1:3]
(2) 修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合 tup1 = (12, 34.56) tup2 = ('abc', 'xyz')
<span style="background-color:var(--color-canvas-subtle)"><span style="color:initial"><code># 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
</code></span></span>输出结果：
(12, 34.56, 'abc', 'xyz')
(3) 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
del tup
(4) 元组运算符
与列表的脚本操作符用法相同
(5) 内置函数
与列表函数基本一致，最后一个改为tuple函数（将列表转换为元组）
5.Set
集合（set）是一个无序的不重复元素序列，可以使用大括号 { } 或者 set() 函数创建集合
进行成员的关系测试和删除重复元素
sites = {1, 2, 3, 4, 3}
if 2 in sites: #成员关系测试
print('在集合中')
else:
print('不在')
print(sites) #会删除重复元素
a = set('1357')
b = set('2345')
print(a & b) #交集
print(a - b) #差集
print(a | b) #并集
print(a ^ b) #ab不同时存在的元素(1) 添加元素
语法：s.add() 或 s.updata()(参数可以是列表，元组，字典等)
<span style="background-color:var(--color-canvas-subtle)"><span style="color:initial"><code>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}</code></span></span>(2) 移除元素
-
语法：s.remove() 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误
-
语法：s.discard( x ) 如果元素不存在，不会发生错误
-
语法：s.pop( x )随机删除集合中的一个元素
<span style="background-color:var(--color-canvas-subtle)"><span style="color:initial"><code> thisset = set(("Google", "Runoob", "Taobao", "Facebook")) x = thisset.pop() print(x) print(thisset) </code></span></span>
输出结果：
Google {'Runoob', 'Facebook', 'Taobao'}
3) 计算集合元素个数
语法：len(s)
(4) 其他函数
clear() 移除集合中的所有元素
copy() 拷贝一个集合
6.Dictionary（字典）
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的
(1) 输入输出
dict = {}
dict['one'] = "1 - 略略"
dict[2] = "2 - 略略"
tinydict = {'name': 'hello','code':1, 'site': 'www.hhh.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值输出结果：
1 - 略略
2 - 略略
{'name': 'hello', 'code': 1, 'site': 'www.hhh.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['hello', 1, 'www.hhh.com'])(2) 访问字典里的值
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
输出结果：
tinydict['Name']: Runoob
tinydict['Age']: 7
(3) 修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "菜鸟教程" # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
输出结果：
tinydict['Age']: 8
tinydict['School']: 菜鸟教程
(4) 删除字典元素
能删单一的元素也能清空字典
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
(5) 键的特性
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
(6) 内置函数
| 函数 | 描述 |
|---|---|
| len(dict) | 计算字典元素个数，即键的总数 |
| str(dict) | 输出字典，可以打印的字符串表示 |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型 |
二.数据类型转换
1. 隐式类型转换
对两种不同类型的数据进行运算，较低的据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失
2. 显示类型转换
类似于强制类型转换三.运算符
1. 算数运算符
| 运算符 | 描述 |
|---|---|
| / | 除法 |
| // | 取整 |
| % | 取余 |
| ** | 幂 |
2. 比较运算符
返回ture或false
3. 赋值运算符
+=、-=之类
4. 位运算符
| 运算符 | 名称 | 描述 |
|---|---|---|
| & | 按位与运算符 | 参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 |
| | | 按位或运算符 | 只要对应的二个二进位有一个为1时，结果位就为1 |
| ^ | 按位异或运算符 | 当两对应的二进位相异时，结果为1 |
| ~ | 按位取反运算符 | 对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 |
| << | 左移动运算符 | 运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0 |
| >> | 右移动运算符 | 把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 |
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b # 12 = 0000 1100
print ("1 - c 的值为：", c)
c = a | b # 61 = 0011 1101
print ("2 - c 的值为：", c)
c = a ^ b # 49 = 0011 0001
print ("3 - c 的值为：", c)
c = ~a # -61 = 1100 0011
print ("4 - c 的值为：", c)
c = a << 2 # 240 = 1111 0000
print ("5 - c 的值为：", c)
c = a >> 2 # 15 = 0000 1111
print ("6 - c 的值为：", c)
输出结果：
1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15
5. 逻辑运算符
假设a = 10、b = 20
| 运算符 | 逻辑表达式 | 描述 | 例子 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
6. 成员运算符
可用于字符串，列表和元组
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True |
a = 10
list = [1, 2, 3, 4, 5 ]
if ( a in list ):
print ("1 - 变量 a 在给定的列表中 list 中")
else:
print ("1 - 变量 a 不在给定的列表中 list 中")
7. 身份运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False |
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
>>>a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True
8. 运算符优先级
- 优先级最高的为指数（**）
- and的优先级高于or
三. 函数
1. 可更改与不可更改对象
(1) 不可变类型
变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
(2) 可变类型
变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
def change(a, b):
a[2] = 5
b = 5
a = [1, 2, 3, 4]
b = 3
change(a, b)
print(a, b)
输出结果：
[1, 2, 5, 4]
3
2. 参数
(1) 必须参数
(2) 关键字参数
def a( str ):
print (str) #打印字符串
return
a( str = "hu")
(3) 默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )
输出结果：
名字: runoob
年龄: 50
--------------------------------------------
名字: runoob 年龄: 35
(4) 不定长参数
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
输出结果：
输出:
70
(60, 50)
加了两个星号 ** 的参数会以字典的形式导入
(5) 匿名参数
lambda 函数的语法只包含一个语句
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))四. 遍历
1. 字典
关键字和对应的值可以使用 items() 方法同时解读出来
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
2. 序列
在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
同时遍历两个或更多的序列，可以使用 zip() 组合
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
