Python笔记(基本入门函数)

第一章 快速上手 :基础知识

1.3 x%y=x-((x//y)*y) 注意求余运算符

​ 向下圆整,如果是负数,则更远离0

10//3
10//-3
10%3
10%-3

​ 十六进制:0x 八进制:0o 十进制:0b

0xAF=175
0o10=8
0b1011010010=722

1.6输入

input("The meaning of life:")
x=input("x:")
y=input("y:")
print(int(x)*int(y))

1.7函数

​ abs 为绝对值 round 为圆整到最近的整数

1.8模块

​ import为导入模块

​ math模块中 floor:小于或等于给数的最大整数

​ ceil:大于或等于给数的最小整数

​ 用一次 from modole import function

from math import sqrt
sqrt()

​ 定义变量来应用函数

foo=math.sqrt
foo(4)

1.81 cmath和复数

j 为虚数单位(即为i)

1.8.2回到未来

—future—

海龟绘图法 turtle.forward(100)

1.10.1单引号与双引号以及对引号转义

​ ''的意义和C中一样,转义字符

1.10.2拼接字符串

​ '+'可用于连接字符串

"Hello,"+"World!"
x="Hello."
y="World"
x+y

1.10.3字符串表示str 和repr

'\n’为换行符

1.10.4长字符串,原始字符串和字节

1.长字符串

要表示很长的字符串(换行),可使用三引号或者三个双引号

常规字符串也可以跨行,只要再末尾加上反斜杠’’

2.原始字符串

前缀r,将不会对反斜杠进行特殊处理,但不能以单个反斜杠结尾

3.Unicode,butes和bytearray

小结:本节函数

abs(number) 返回绝对值

cmath.sqrt(number) 返回平方根,可用于负数

math.sqrt() 返回平方根,不可用于复数

floa他(object) 转化为浮点型

help([object]) 提供交会时帮助

input() 输入

int() 转化为整型

math.ceil() 浮点型方式返回向上圆整结果

math.floor() 浮点型方式返回向下圆整结果

pow(x,y[ ,z]) 返回X的Y次方对z求模的结果

print 输出

round(number[ ,ndights]) 四舍五入为指定精度

第二章 列表与元组

2.1 序列概述

a=['long',1]
b=['weng',2]
database=[a,b]

2.2通用的序列操作

2.2.1索引

greeting = 'Hello'
greeting[0]
greeting[-1]

括号内为负数时从右往左数,可直接在字符串后引用,也是从零开始

fourth=input('year: ')[3]
year:2005
    fourth
    

2.2.2切片

除了用索引引用一个时,可以用切片提取一部分的,第一个索引为包含的第一个元素的编号,第二个索引为切片后余下的第一个元素的编号,中间用冒号隔开

步长:

[ a: b : c ],a,b同上,而c则为步长,从a开始跳过c各单位取数,也可以为负数从右向左

a=[1,2,3,4,5,6]
a[-3:-1]
[4,5]

2.2.3序列相加(拼接)

必须拼接相同的类型序列 用‘+’连接

2.2.4相乘

序列与数相乘代表序列的重复次数

2.25成员资格

成员资格: x in y,True or False

database = [['albert','1234'],['dilbert','4242'],['smith','7542'],['jones','9843']]
username = input('Usename: ')
pin = input('PIN code: ')
if[username,pin] in database: print('Access granted')

2.3列表:python的主力

2.3.1函数list

list('Hello')
['H','e','l','l','o']

可将任意序列作为list的参数

字符列表转换为字符串:‘ ’.join(somelist)

2.3.2基本的列表操作

1.修改列表:给元素赋值

通过索引表示法来给特定位置的元素进行赋值

2.删除元素

用del语句进行删除

names = ['a','b','c']
del names[2]

3给切片赋值

name = list('perl')
['p','e','r','l']
name[2:] = list('ar')
name = list('perl')
name[1:] = list('ython')
name = [1,5]
name[1:1] = [2,3,4]
numbers = [1,2,3,4,5]
numbers[1:4] = [ ]

2.3.3列表方法

1.append

将对象添加到列表末尾

1st=[1,2,3]
1st.append(1)

2.clear

清空列表

1st=[1,2,3]
1st.clear()

3.copy

常规赋值,相关联

a=[1,2,3]
b=a
b[1]=4
a
a=[1,4,3]
a=[1,2,3,4]
b=a.copy()
a
[1,2,3,4]

4.count

用于计算出现了多少次

['to','to','to','dg','tr'].count('to')

x=['to','to','to','dg','tr']
x.count('to')

5.extend

列表来扩展列表

a=[1,2,3]
b=[4,5,6]
a.extend(b)
a
[1,2,3,4,5,6]

a=[1,2,3]
b=[4,5,6]
a+b
a
[1,2,3]

6.index

查找指定值第一次出现的索引

knights=['we','are','the','knights','who','say','ni']
knights.index('who')
4

7.insert

将一个对象插入列表

numbers=[1,2,3,4,5,6,7]
nimbers.insert(3,'four')
numbers
[1,2,3,'four',5,6,7]

8.pop

从列表删去一个元素,并返回这一元素

x=[1,2,3]
x.pop()
3
x.pop(0)
1
x
2
x=[1,2,3]
x.append(x.pop())
x
[1,2,3]

9.remove

删除第一个为指定值的元素

x=['to','bo','or','not','to','be']
x.remove('be')
x
['to','or','not','to','be']

10.reverse

按相反的顺序排列

x=[1,2,3]
x.reverse()
x
[3,2,1]

11.sort

对列表就地排序

x=[4,6,2,1,7,9]
x.sort()
x
[1,2,4,6,7,9]

x=[4,6,2,1,7,9]
y=x.copy()
y.sort()
x
[4,6,2,1,7,9]
y
[1,2,4,6,7,9]

x=[4,6,2,1,7,9]
y=sorted(x)
y
[1,2,4,6,7,9]

12.高级排序

sort(sorted)接受两个可选参数:key 和 reverse

key:不会直接比较大小而是通过为每一个函数设置一个键,再根据这些键进行排序

x=['a','aaaaa','aa','aaaa','aaa']
x.sort(key=len)
x
['a','aa','aaa','aaaa','aaaaa']

reverse:为其指定一个真值,以指出是否按相反顺序进行排序

x=[4,6,2,1,7,9]
x.sort(reverse=True)
x
[9,7,6,4,2,1]

2.4元组:不可修改的序列

用逗号隔开,自动创建元组

1,2,3
(1,2,3)

(1,2,3)
(1,2,3)

()
()

42
42

42,
(42,)

3*(40+2)
126
3*(40+2,)
(42,42,42)

tuple:将序列作为参数,并将其转换为元组,如果已经是元组,则原封不动的返回,和list相似

tuple([1,2,3])
(1,2,3)
tuple('abc')
('a','b','c')

小结

1.序列:

序列:列表,字符串,元组

​ 列表可变,元组和字符串不可变

2.成员资格

3.方法

4.新函数

len(seq) 返回序列长度

list(seq) 将序列转换为列表

max(arges) 返回列表或参数中的最大值

min(arges) 返回列表或参数中的最小值

reverse(seq) 反向迭代序列

sorted(seq) 返回一个有序列表

tuple(seq) 将序列转换为元组

第三章 使用字符串

3.2设置字符串格式:精简版

format = "Hello,%s. %s enough for ya?"
values = ('world','Hot')
format%values
'Hello,world.Hot enough for ya?'

%转换说明符 s意味着将值视为字符串进行格式转换 %.3f将值格式设置为包含3位小数的浮点数

"{},{} and {}".format('first','second','third')
first,second and third

.format 需替换的部分用{}包括起来(里面可以有值)之后将需要的部分包含在后面的()括号中用’‘包起

也可以用索引,则无需按顺序排列

"{2},{1} and {0}".format('third','second','first')
first,second and third

也可以直接命名

"{2},{1} and {0}".format('0=third','1=second','2=first')
first,second and third

如果变量与替换字段同名 则可以用简写 但在前面需要添加f

from math import e
f"Euler's constant is roughly {e}."
"Euler's constant is roughly 2.7182818."

3.3设置字符串的格式:完整版

"{foo}{}{bar}{}".format(1,2,bar=4,foo=3)

3.3.1 替换字段名

3.3.2 基本转换

‘!’+‘s’,‘r’,‘a’ ‘s’:普通字符串版本 ‘r’:字符串字面量 ‘a’:ASCLL字符表示

‘:’+

3.3.3 宽度,精度和千位分隔符

‘:’ 宽度 ‘.’:精度 ','千位分隔符

3.3.4 符号,对齐和用0填充

‘<’:左对齐 ‘>’:右对齐 ‘^’:居中

‘+’:加上符号(在对齐说明符后)

‘#’:符号说明符和宽度之间,

3.4.1 center

在两边填充字符(默认为空格)让字符串居中

‘.center(39,"#")’

3.4.2 find

在字符串中找子串,返回 索引 .find( , 起点,终点)

3.4.3 join

合并字符串

3.4.4 lower

转变为小写 title转变为大写

3.4.5 replace

替换字符串 .replace(’ ‘,’ ')

3.4.6 split

拆分字符串 .split(’ ')

3.4.7 strip

删除字符串中指定值 .strip(’ ')

3.4.8 translate

table = str.maketrans('cs','kz')
'this is an incredible test'.translate(table)
'thiz iz aninlredible tezt'

3.4.9 判断字符串是否满足特定的条件

'is ’

新函数

.capwords(s[ , sep]) 使用split拆分s,将每项的首字母大写,在以空格为分隔符将他们合并起来

ascii(obj) 创建指定对象的ASCII表示

第四章 当索引行不通

4.2 创建和使用字典

phonebook = {‘alice’:‘3121’,‘robin’:‘1641’,‘cecil’:‘2155’} 键 : 值 合成项

4.2.1 函数 dict

从其他映射或键值中创建一个字典

a=[('name','robin'),('age','19')]
d=dict(items)
d
{'age':19,'name':robin}

d=dict(name='robin',age='19')
d
{'age':19,'name':robin}

4.2.4 字典方法

1.clear

clear会清除所有

2.copy

浅复制 替换不受影响,修改则会

form copy import deepcopy 深复制 则不会受影响

3.fromkey

创建一个字典,其中包含指定键,其中的值为None

也可以给它复制

dict.fromkey(['name','age'],['unknown'])
{'age':'unknown','name':'unknown'}

4.get

从字典中访问,如果没有,则返回None,也可以自己设置

5.items

返回一个字典里面的列表,其中每个元素都为(key,value)

6.keys

返回字典中的键

7.pop

获取指定键,并将键-值同时从字典中删除

8.popitem

同pop,但是随机

9.setdefault

类似于get,但如果原字典中没有该值,则会自动添加

10.update

使用一个字典的项来更新另一个字典,如果包含相同的键,则替换其中的值

11.values

类似于keys,但其中可以包含相同的值

第五章 条件,循环和其他语句

5.4.4 elif

elif==else if

5.4.6 更复杂的运算

1比较运算符

is 检查两个对象是否相同(指向同一个对象),而‘==’则判断是否相等

in 是否是容器的成员

可以是用链式比较

2.布尔运算符

‘||’==and 还有 or 和not

5.5.4 一些迭代工具

1.并行迭代

zip将两个序列缝合起来 并返回一个有元组组成的序列,以最短的长度来作为标准

2.迭代是获取索引

enumerate 获取想要的索引,并可进行替换

5.7 三人行

5.7.1 什么都不做

pass 过

5.7.2 使用del来删除

5.8 小结

5.8.1 新函数

chr(n)

返回一个字符串,字符串对应于输入的顺序值n

eval(source[,globals[,lcols]])

计算并返回字符串表示的表达式的结果

exec(source[,globals[,lcols]])

将字符串作为语句执行

enumerate(seq)

生成可迭代的索引 值

ord( c)

接 受 一 个 只 包 含 一 个 字 符 的 字 符 串, 并 返 回 这 个 字 符 的 顺 序 值( 一 个 整 数)

range([ start,] stop[, step])

创 建 一 个 由 整 数 组 成 的 列 表

reversed( seq)

按 相 反 的 顺 序 返 回 seq 中 的 值, 以 便 用 于 迭 代

sorted( seq[, cmp][, key][, reverse])

\返 回 一 个 列 表, 其 中 包 含 seq 中 的 所 有 值 且 这 些 值 是 经 过 排 序 的

xrange([ start,] stop[, step])

创 建 一 个 用 于 迭 代 的 xrange 对 象

zip( seq1, seq2,…)

创 建 一 个 适 合 用 于 并 行 迭 代 的 新 序 列

eval()

函数用来执行一个字符串表达式,并返回表达式的值。

第六章 抽象

6.4.4 收集参数

def print(*paramas)

*将提供的所以值都放在一个元组里面,也就是将这些值收集起来

** 如果拥有两个星号,则会得到一个字典(收集关键字参数)

[]:列表 ():元组 {}:字典

小结 函数

map( func, seq[, seq, …]) 对 序 列 中 的 所 有 元 素 执 行 函 数 filter( func, seq) 返 回 一 个 列 表, 其 中 包 含 对 其 执 行 函 数 时 结 果 为 真 的 所 有 元 素

reduce( func, seq[, initial]) 等 价 于 func( func( func( seq[ 0], seq[ 1]), seq[ 2]), …)

sum( seq) 返 回 seq 中 所 有 元 素 的 和

apply( func[, args[, kwargs]]) 调 用 函 数( 还 提 供 要 传 递 给 函 数 的 参数

blocked()

将括号内的元素变为空格

第七章 再谈抽象

对象:

由属性和方法组成。属 性 不 过 是 属 于 对 象 的 变 量, 而 方 法 是 存 储 在 属 性 中 的 函 数。 相 比 于 其 他 函 数,( 关 联 的) 方 法 有 一 个 不 同 之 处, 那 就 是 它 总 是 将 其 所 属 的 对 象 作 为 第 一 个 参 数, 而 这 个 参 数 通 常 被 命 名 为 self。

多态:

对不同类型的对象可以执行相同的操作

封装:

对外部隐藏有关对象工作原理的细节

继承:

可基于通用类创建专用类

class:创建类

7.2.7 深入讨论继承

issubclass:确定一个类是否是另一个类的子类

bases:想知道一个类的子类

isinstance:是否为特殊类

class:获悉对象是哪一个类

7.2.8 多个超类

多重继承

如果两个类中有相同的方法,则前一个将覆盖后一个,可以通过顺序来决定执行的方法

Talk.register(Herring):将Herring注册为Talker

新函数:

callable( object)

判 断 对 象 是 否 是 可 调 用 的( 如 是 否 是 函 数 或 方 法)

getattr( object, name[, default])

获 取 属 性 的 值, 还 可 提 供 默 认 值

hasattr( object, name)

确 定 对 象 是 否 有 指 定 的 属 性

isinstance( object, class)

确 定 对 象 是 否 是 指 定 类 的 实 例

issubclass( A, B)

确 定 A 是 否 是 B 的 子 类

random.choice( sequence)

从 一 个 非 空 序 列 中 随 机 地 选 择 一 个 元 素

setattr( object, name, value)

将 对 象 的 指 定 属 性 设 置 为 指 定 的 值 type( object) 返 回 对 象 的 类 型

第八章 异常

一些内置的异常类

Exception 几 乎 所 有 的 异 常 类 都 是 从 它 派 生 而 来 的 AttributeError 引 用 属 性 或 给 它 赋 值 失 败 时 引 发

OSError 操 作 系 统 不 能 执 行 指 定 的 任 务( 如 打 开 文 件) 时 引 发, 有 多 个 子 类

IndexError 使 用 序 列 中 不 存 在 的 索 引 时 引 发, 为 LookupError 的 子 类

KeyError 使 用 映 射 中 不 存 在 的 键 时 引 发, 为 LookupError 的 子 类

NameError 找 不 到 名 称;( 变 量) 时 引 发

SyntaxError 代 码 不 正 确 时 引 发

TypeError 将 内 置 操 作 或 函 数 用 于 类 型 不 正 确 的 对 象 时 引 发

ValueError 将 内 置 操 作 或 函 数 用 于 这 样 的 对 象 时 引 发: 其 类 型 正 确 但 包 含 的 值 不 合 适

ZeroDivisionError 在 除 法 或 求 模 运 算 的 第 二 个 参 数 为 零 时 引 发

8.3   捕 获 异 常

前 面 说 过, 异 常 比 较 有 趣 的 地 方 是 可 对 其 进 行 处 理, 通 常 称 之 为 捕 获 异 常。 为 此, 可 使 用 try/ except 语 句。 假 设 你 创 建 了 一 个 程 序, 让 用 户 输 入 两 个 数, 再 将 它 们 相 除, 如 下 所 示:

x = int( input(' Enter the first number: '))
y = int( input(' Enter the second number: ')) 
print( x / y)

8.3.2 多个except语句

try: 
    x = int( input(' Enter the first number: '))
    y = int( input(' Enter the second number: ')) 		print( x / y) 
except ZeroDivisionError: 
    print(" The second number can't be zero!")
except TypeError: 
    print(" That wasn't a number, was it?")

8.3.6 万事大吉时

一 种 更 佳 的 替 代 方 案 是 使 用 空 的 except 子 句 来 捕 获 所 有 属 于 类 Exception( 或 其 子 类) 的 异 常。 你 不 能 完 全 确 定 这 将 捕 获 所 有 的 异 常, 因 为 try/ except 语 句 中 的 代 码 可 能 使 用 旧 式 的 字 符 串 异 常 或 引 发 并 非 从 Exception 派 生 而 来 的 异 常。 然 而, 如 果 使 用 except Exception as e, 就 可 利 用 8.3.4 节 介 绍 的 技 巧 在 这 个 小 型 除 法 程 序 中 打 印 更 有 用 的 错 误 消 息。

8.3.7   最 后

x = None
try: 
    x = 1 / 0 
 finally:
    print(' Cleaning up ...') 
    del x

8.7   小 结

本 章 介 绍 了 如 下 重 要 主 题。

异 常 对 象: 异 常 情 况( 如 发 生 错 误) 是 用 异 常 对 象 表 示 的。 对 于 异 常 情 况, 有 多 种 处 理 方 式; 如 果 忽 略, 将 导 致 程 序 终 止。

引 发 异 常: 可 使 用 raise 语 句 来 引 发 异 常。 它 将 一 个 异 常 类 或 异 常 实 例 作 为 参 数, 但 你 也 可 提 供 两 个 参 数( 异 常 和 错 误 消 息)。 如 果 在 except 子 句 中 调 用 raise 时 没 有 提 供 任 何 参 数, 它 将 重 新 引 发 该 子 句 捕 获 的 异 常。

自 定 义 的 异 常 类: 你 可 通 过 从 Exception 派 生 来 创 建 自 定 义 的 异 常。

捕 获 异 常: 要 捕 获 异 常, 可 在 try 语 句 中 使 用 except 子 句。 在 except 子 句 中, 如 果 没 有 指 定 异 常 类, 将 捕 获 所 有 的 异 常。 你 可 指 定 多 个 异 常 类, 方 法 是 将 它 们 放 在 元 组 中。 如 果 向 except 提 供 两 个 参 数, 第 二 个 参 数 将 关 联 到 异 常 对 象。 在 同 一 条 try/ except 语 句 中, 可 包 含 多 个 except 子 句, 以 便 对 不 同 的 异 常 采 取 不 同 的 措 施。

else 子 句: 除 except 子 句 外, 你 还 可 使 用 else 子 句, 它 在 主 try 块 没 有 引 发 异 常 时 执 行。

finally: 要 确 保 代 码 块( 如 清 理 代 码) 无 论 是 否 引 发 异 常 都 将 执 行, 可 使 用 try/ finally, 并 将 代 码 块 放 在 finally 子 句 中。

异 常 和 函 数: 在 函 数 中 引 发 异 常 时, 异 常 将 传 播 到 调 用 函 数 的 地 方( 对 方 法 来 说 亦 如 此)。

警 告: 警 告 类 似 于 异 常, 但( 通 常) 只 打 印 一 条 错 误 消 息。 你 可 指 定 警 告 类 别, 它 们 是 Warning 的 子 类。

8.7.1   本 章 介 绍 的 新 函 数

warnings.filterwarnings( action, category = Warning, …) 用 于 过 滤 警 告

warnings.warn( message, category = None) 用 于 发 出 警 告

第九章 魔法方法,特性和迭代器

9.3.1   基 本 的 序 列 和 映 射 协 议

len( self):

这 个 方 法 应 返 回 集 合 包 含 的 项 数, 对 序 列 来 说 为 元 素 个 数, 对 映 射 来 说 为 键-值 对 数。 如 果__len__ 返 回 零( 且 没 有 实 现 覆 盖 这 种 行 为 的__nonzero__), 对 象 在 布 尔 上 下 文 中 将 被 视 为 假( 就 像 空 的 列 表、 元 组、 字 符 串 和 字 典 一 样)。

getitem( self, key):

这 个 方 法 应 返 回 与 指 定 键 相 关 联 的 值。 对 序 列 来 说, 键 应 该 是 0 ~ n - 1 的 整 数( 也 可 以 是 负 数, 这 将 在 后 面 说 明), 其 中 n 为 序 列 的 长 度。 对 映 射 来 说, 键 可 以 是 任 何 类 型。

setitem( self, key, value):

这 个 方 法 应 以 与 键 相 关 联 的 方 式 存 储 值, 以 便 以 后 能 够 使 用__getitem__ 来 获 取。 当 然, 仅 当 对 象 可 变 时 才 需 要 实 现 这 个 方 法。

delitem( self, key):

这 个 方 法 在 对 对 象 的 组 成 部 分 使 用__del__ 语 句 时 被 调 用,应 删 除 与 key 相 关 联 的 值。 同 样, 仅 当 对 象 可 变( 且 允 许 其 项 被 删 除) 时, 才 需 要 实 现 这 个 方 法。

9.5.1 函数property

9.5.3  getattrsetattr 等 方 法

getattribute( self, name):

在 属 性 被 访 问 时 自 动 调 用( 只 适 用 于 新 式 类)。

getattr( self, name):

在 属 性 被 访 问 而 对 象 没 有 这 样 的 属 性 时 自 动 调 用。

setattr( self, name, value):

试 图 给 属 性 赋 值 时 自 动 调 用。

delattr( self, name):

试 图 删 除 属 性 时 自 动 调 用。

9.6 迭代器

iter__与__next

9.7 生成器

yield语句

9.9   小 结

新 式 类 和 旧 式 类:

Python 类 的 工 作 方 式 在 不 断 变 化。 较 新 的 Python 2 版 本 有 两 种 类, 其 中 旧 式 类 正 在 快 速 退 出 舞 台。 新 式 类 是 Python 2.2 引 入 的, 提 供 了 一 些 额 外 的 功 能, 如 支 持 函 数 super 和 property, 而 旧 式 类 不 支 持。 要 创 建 新 式 类, 必 须 直 接 或 间 接 地 继 承 object 或 设 置__metaclass__。

魔 法 方 法:

Python 中 有 很 多 特 殊 方 法, 其 名 称 以 两 个 下 划 线 开 头 和 结 尾。 这 些 方 法 的 功 能 各 不 相 同, 但 大 都 由 Python 在 特 定 情 况 下 自 动 调 用。 例 如__init__ 是 在 对 象 创 建 后 调 用 的。

构 造 函 数:

很 多 面 向 对 象 语 言 中 都 有 构 造 函 数, 对 于 你 自 己 编 写 的 每 个 类, 都 可 能 需 要 为 它 实 现 一 个 构 造 函 数。 构 造 函 数 名 为__init__, 在 对 象 创 建 后 被 自 动 调 用。

重 写:

类 可 重 写 其 超 类 中 定 义 的 方 法( 以 及 其 他 任 何 属 性), 为 此 只 需 实 现 这 些 方 法 即 可。 要 调 用 被 重 写 的 版 本, 可 直 接 通 过 超 类 调 用 未 关 联 版 本( 旧 式 类), 也 可 使 用 函 数 super 来 调 用( 新 式 类)。

序 列 和 映 射:

要 创 建 自 定 义 的 序 列 或 映 射, 必 须 实 现 序 列 和 映 射 协 议 指 定 的 所 有 方 法, 其 中

iter( obj)

从 可 迭 代 对 象 创 建 一 个 迭 代 器

next( it)

让 迭 代 器 前 进 一 步 并 返 回 下 一 个 元 素

property( fget, fset, fdel, doc)

返 回 一 个 特 性; 所 有 参 数 都 是 可 选 的

super( class, obj)

返 回 一 个 超 类 的 关 联 实 例

你可能感兴趣的:(Python爬虫,python)