python3入门

由于比较羡慕python的爬虫技术，所有写一篇python的笔记供查阅

presen = input(‘输入一个数’)

print(presen)

print(‘helloworld’)

注意点：1.使用的盘符需要存在 2.使用file = fp

fp = open(‘D:/hello.txt’,‘a+’) #a+是说如果文件不存在则新建，存在就在文件内容的后面追加
print(‘hello’,file=fp) #文件当中有hello文字
fp.close()

不进行换行输出

print(‘asd’,‘asd’,‘asda’) # asd asd asda
print(‘hel\nlo’) # 换行 \r覆盖 \b退一格
#原字符 可以让\不起作用 注意：最后一个字符不能是反斜杠
print(r’ads\ndsa’) # ads\ndsa
name = ‘asds’ # 变量中有id value type
print(‘类型’,type(name))
print(‘值’,name)

‘’’ ‘’’ 三引号可以换行输出，写成什么样就输出什么样 多行注释也是这样

数据类型转换有三种 str() float() int() float => int 会舍弃掉小数部分 int（）文字和小数字符串我发转换为int int=>float 默认.0

#运算符
print(11//2) #5 //整除运算符 /除法运算符 ** 幂运算符2**3=8
print(-9//4) #-3 一正一负整除向下取整
print(9%-4) # -3 取余一正一负按公式 余数= 被除数 - 除数商 9-（-4） （-3） =-3
print(-9%4) # 3 -9 - 4*（-3） = —9 + 12 = 3

解包赋值 a,b,c = 10,20,30 is 和 is not 比较的是对应的id值

布尔运算符 and 一否全否 or 一是全是 not 对运算数（boolean）取反 如 not false = true in和not in 判断A是否在B中

运算符 位运算 就是换算成2进制0010001这种来进行与或操作和换位

print(4&8) #按位与&,同时为1结果为1
print(4|8) #按位或|，同时为0结果为0
print(4<<1) #向左移动1位（移动一个位置）相当于乘以2
print(4<<2) #向左移动两个位置 相当于乘4
print(4>>1) #向右移动1位，相当于除以2

运算符优先级 ** -> * -> / ->+ - << -> & -> | ><>=<= and -> or -> =

#对象的布尔值 利用bool(None,[],0)来包裹内部对象

分支结构 搭建结构的话可以先写pass，什么也不做，只是占一个语句的位置

‘’‘if 条件表达式:
条件执行体
else:
条件执行体
‘’’

多分支结构

‘’‘if 条件表达式1: 嵌套结构
条件执行体
elif 条件表达式2:
条件执行体
elif 条件表达式2:
条件执行体
[else:]可写可不写
‘’’

条件表达式 就是if else的简写

‘’‘语法结构
x if 判断条件 else y
如果为true则x为返回值，否则y为返回值
‘’’

循环结构

‘’’
语法结构：while 条件表达式:
执行条件循环体

‘’’
sum = 0
a = 1
while a <= 100:
if a % 2 == 0:
sum+=a
a += 1
print(sum) # 2550

for in循环 如果循环中不使用前面i变量值的话可以写成 “_” 来替代

‘’’
for i in range(5):
print(i) # 1 2 3 4
‘’’

#内置函数range() 用于生成一个整数序列,返回值是一个迭代值，需要用list来显示出来
‘’’
优点：不管range表示的序列有多长，所占的内存空间都是相同的，因为它只存储start,stop,step，用的时候才会计算相关元素
创建range()对象的三种方式
range(stop) -> 创建一个[0,stop）之间的整数序列，步长为1
range(start,stop) -> 创建一个[start,stop）之间的整数序列，步长为1
range(start,stop,step) -> 创建一个[start,stop）之间的整数序列，步长为step
例子：
r = range(5) r = range(5,10,2)
print(list®) //[1,2,3,4] print(list®) //[5,7,9]
‘’’

判断指定整数 在序列中是否存在 in ， not in print(10 in r)

#字符串的常用操作
‘’’
index（） 查找的子串第一次出现的位置，不存在抛出异常 例：asd.index(‘io’) # 3
find() 同上，不存在返回-1
rindex() 查找的子串最后一次出现的位置，不存在抛出异常
rfind() 同上，不存在返回-1
replace(old, new [, max]) 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
例：str = “this is string example…wow!!!”
print (str.replace(“is”, “was”, 3)) #thwas was string example…wow!!!
join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
s1 = “-”
s2 = “”
seq = (“r”, “u”, “n”, “o”, “o”, “b”) # 字符串序列
print (s1.join( seq )) //r-u-n-o-o-b
‘’’

字符串大小写

‘’’
upper() 把字符串都转换成大写字母
lower() 把所有字符都转换成小写字母
swapcase() 把大写转小写，小写转大写
capitalize() 把第一个字母大写，其余小写
title（） 把每个单词第一个转大写，每个单词剩余字母转小写
‘’’

字符串的分割

‘’’
split()
str = “this is string example…wow!!!”
print (str.split( )) # 以空格为分隔符[‘this’, ‘is’, ‘string’, ‘example…wow!!!’]
print (str.split(‘i’,1)) # 以 i 为分隔符[‘th’, ‘s is string example…wow!!!’]
print (str.split(‘w’)) # 以 w 为分隔符[‘this is string example…’, ‘o’, ‘!!!’]
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。默认为 -1, 即分隔所有。

rsplit()  是从右边开始分割

‘’’

判断字符串

‘’’
isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isdigit() 如果字符串只包含数字则返回 True 否则返回 False…
isalpha() 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
==和is的区别： ==比较的是value的值大小，而is比较的是对应的id是否相同
‘’’

字符串格式化

‘’’
https://m.runoob.com/python3/python3-string.html
print (“我叫 %s 今年 %d 岁!” % (‘小明’, 10)) #我叫 小明 今年 10 岁!
第二种方式：例：
print(‘{}0:.3’.format(3,1415926)) # .3表示的是一共三位数
print(‘{}0:.3f’.format(3,1415926)) # 3f表示的是3位 小数
‘’’

字符的编码和解码

#byte代表的就是一个二进制数据（子节类型的数据）
s = ‘天雅安市的’
byte = s.encode(encoding=‘UTF-8’)
print(byte)
print(byte.decode(encoding=‘UTF-8’))

列表

‘’’
列表的创建：lst=[] lst=list([])
索引分为正向和逆项：正向从0开始，逆项的话最后一项为-1往前以此类推
注意：如果列表中有多个相同元素，index只返回第一项
‘’’
#index 查找对应元素存在的索引
lst = [‘hello’,98,‘asd’]
print(lst.index(‘hello’)) # 0
print(lst.index(98,0,3)) #1
#获取列表中的多个元素 切片操作
‘’’
语法格式： 列表名[start:stop:step]
start不写默认第一个开始 步长默认为1
step为负数的情况 就会把整个列表反过来
‘’’
lst = [10,20,30,20,10,20]
print(lst[1:3:1]) # 20 30
print(lst[::-1])
print(lst[1::-1])
#列表元素的查询操作
‘’’
判断指定元素在列表中是否存在
元素 in 列表名
元素 not in 列表名
列表元素的遍历
for 迭代变量 in 列表名:
操作
‘’’

列表的增加操作

‘’’
append 向列表的末尾添加一个元素
extend 向列表末尾添加至少一个元素
insert 向列表任意位置上添加一个元素
切片 向列表的任意位置添加至少一个元素
‘’’
lst = [10,20,30]

append

lst.append(100)
print(lst) # [10, 20, 30, 100]

extend

lst2 = [122,333]
lst.extend(lst2)
print(lst) #[10, 20, 30, 100, 122, 333]

insert

lst.insert(1,90)
print(lst) #[10, 90, 20, 30, 100, 122, 333]

切片

lst[2:4] = ‘asd’
print(lst) #[10, 90, ‘a’, ‘s’, ‘d’, 100, 122, 333]

#列表元素的删除操作
‘’’
remove 从列表中移除一个元素，如果有重复元素只删第一个 ,参数为删除的值 lst.remove()
pop 根据索引移除元素，如果没有参数自动删除最后一项 lst.pop(1)
切片 删除至少一个元素，将产生至少一个新的列表对象 如果不想产生新的对象，而是删除原列表中的内容 lst[1:3]=[]即可
clear 清空列表中所有元素 lst.cear()
del 将列表对象删除
‘’’
asd= [10,20,30,40]
asd.remove(20)
print(asd)

#列表元素的修改操作
list = [10,20,30]
list[2] = 22
print(list) #[10, 20, 22]
list[1:3] = [100,200,300]
print(list) # [10, 100, 200, 300]

#列表元素的排序操作
‘’’
常见的两种方式：
1.sort(),可以指定关键字reverse=True参数来进行升序和降序操作 不产生新的对象
2.内置函数sorted()对列表进行排序，也是可以使用reverse来改变， 产生一个新的列表对象
‘’’
lst = [10,20,30]

sort（）

lst.sort(reverse=True)
print(lst) # [30, 20, 10]

sorted

desc_list = sorted(lst,reverse=True)
print(desc_list)

列表生成式 简称：生成列表的公式

‘’’
语法格式：
[ ii for i in range(1,10)]
ii 为表达式 决定最终生成的列表
‘’’
#案例:生成列表[2,4,6,8,10]
lst = [i*2 for i in range(1,6)]
print(lst) #[2, 4, 6, 8, 10]

#字典的创建
‘’’
最常用的方式：使用花括号 scores = {‘张三’:100,‘李四’：98}
使用内置函数 dict() dict(name= ‘jack’,age = 20)
‘’’

获取字典中的元素值

‘’’
第一种方式 ： 使用[] scores[‘张三’]
第二种方式 : 使用get（）方法
区别：[]如果没有对应键会报错
get() 如果没有对应键，会输出None，并且可以设置找不见时的默认值,也就是第二个参数
scores.get(‘马奇’,99)
‘’’

key的判断

‘’’
in 例：print(‘张三’ in scores) true
not in 例：print(‘张三’ not in scores) false
‘’’
#字典元素删除
‘’’
del 删除指定的key-value键值对 例：del scores[‘张三’]
清空字典的元素 例： scores.clear()
‘’’

字典元素新增

‘’’
scores[‘jack’] = 90
‘’’

获取字典视图的三个方法

‘’’
keys() 获取所有的键 例：keys = scores.keys() #([键值，键值]) 利用list(keys)将视图转换为列表 #[键值，键值]
values() 获取所有的value 例：同上.values() 也用list（key）转化为视图
items() 获取所有的key-value对 例：items = scores.items() #[(‘张三’，100),(‘wangwu’,120)] 元组
‘’’

字典元素的遍历

‘’’
这里的item就是所有字典元素的键
for item in scores:
print(item,scores[item],scores.get(item))
‘’’

字典的特点

‘’’
key不允许重复，value可以重复
字典中元素是无序的
字典中key必须是不可变对象
字典可以根据需要动态的收缩
字典会浪费较大的内存，是一种空间换时间的数据结构
‘’’

字典生成式,

‘’’
语法结构：
{键:值 for 键,值 in zip(键，值)}
‘’’
items = [‘Frasd’,‘Book’,‘asd’]
price = [12,39,76]
d = {item:price for item,price in zip(items,price)}
print(d) #{‘Frasd’: 12, ‘Book’: 39, ‘asd’: 76}
#如果要把键全部转换为大写
d = {item.upper():price for item,price in zip(items,price)}
print(d) #{‘FRASD’: 12, ‘BOOK’: 39, ‘ASD’: 76}

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

‘’’
语法结构：
def 函数名（参数列表）:
函数体
匿名函数：
使用 lambda 来创建匿名函数。
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

可写函数说明

sum = lambda arg1, arg2: arg1 + arg2

调用sum函数

print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

‘’’

创建多个匿名函数

def myfunc(n):
return lambda a: a * n
mydoubler = myfunc(2)
mytripler = myfunc(3)
print(mydoubler(11))#22
print(mytripler(11))#33

#利用global进行声明全局函数

a = 10

def test(a):
a = a + 1
print(a)

test(a) #11

异常的处理

‘’’
try 语句按照如下方式工作；

首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。
如果没有异常发生，忽略 except 子句，try 子句执行后结束。
如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。
一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

try/except…else
try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。

else 子句将在 try 子句没有发生任何异常的时候执行。

try-finally 语句
try-finally 语句无论是否发生异常都将执行最后的代码。

异常类型：ZeroDivisionError 除零
indexError 序列中没有此索引
KeyError 映射中没有这个键
NameError 未声明/初始化对象
SyntaxError Python 语法错误
ValueError 传入无效的参数
‘’’