Python爬虫前置知识

你的名字 2022-09-11 05:13 183阅读 0赞

## 注释 ##

单行注释：\#

多行注释：’‘’

# print('你不好使') 因为你把代码写在了注释的后面
    
    # 多行注释
    ''' print('哈哈') print('嘿嘿') '''

## 数据类型 ##

*  Number 数值 (int/float)
 *  boolean 布尔
 *  string 字符串（使用的是单引号 或者双引号）
 *  list 列表
 *  tuple 元组
 *  dict 字典

# Number     数值
    money = 5000	#int
    money1 = 1.2	#float
    
    # boolean    布尔
    sex = True
    gender = False
    
    # string     字符串  	使用的是单引号 或者双引号
    s1 = "嘀嗒嘀嗒嘀"
    
    # 单引号和双引号的嵌套
    s4 = '"嘿嘿嘿"'
    s5 = "'嘿嘿'"
    
    # list  列表
    name_list = ['周杰伦','科比']
    
    # tuple 元组
    age_tuple = (18,19,20,21)
    
    # dict  字典
    # 格式：变量的名字 = {key:value,key1:value1}
    person = {'name':'红浪漫','age':18}

> 单引号和双引号可以互为嵌套，但单引号不能套单引号 双引号不能套双引号

type方法判断变量的数据类型：格式：type（变量）

## 类型转换 ##

转换为整型：int()

# str --> int
    a = '123'
    print(type(a))
    b = int(a)
    print(type(b))
    
    # float --> int
    a = 1.63
    print(type(a))
    b = int(a)
    print(type(b))
    
    # boolean --> int
    a = False
    print(type(a))
    b = int(a)
    print(type(b))
    
    a = '1.23'
    print(type(a))
    b = int(a)
    print(b)
    
    a = '12ab'
    print(type(a))
    b = int(a)
    print(b)

> 123.456 和 12ab 字符串，都包含非法字符，不能被转换成为整数，会报错
> 
> 将float转为整数 那么会返回的是小数点前面的数据

转换为浮点数：float()

a = '12.34'
    print(type(a))
    b = float(a)
    print(type(b))
    
    a = 666
    print(type(a))
    b = float(a)
    print(type(b))

转换为字符串：str()

a = 80
    print(type(a))
    b = str(a)
    print(type(b))
    
    a = 1.2
    print(type(a))
    b = str(a)
    print(type(b))
    
    # 布尔类型转换为字符串
    a = True
    print(type(a))
    b = str(a)
    print(type(b))

转换为布尔：bool()

# 什么情况下是False
    print(bool(0))
    print(bool(0.0))
    print(bool(''))
    print(bool(""))
    print(bool([]))
    print(bool(()))
    print(bool({ }))

## 输出/输入 ##

# 普通输出
    print('故事里的小黄花，从出生那年就飘着')
    
    # 格式化输出
    age = 18
    name = '红浪漫晶哥'
    # %s 代表的是字符串 %d 代表的是数值
    print('我的名字是%s,我的年龄是%d' % (name,age))
    
    # 输入
    name = input('请输入您的名字')
    print('我的名字是:%s' % name)

## 条件判断 ##

# 在控制台上输入您的成绩分数
    # 如果你考了90以上 成绩为优秀
    # 如果你考了80以上 成绩为良好
    # 如果你考了70以上 成绩为中等
    # 如果你考了60以上 成绩为合格
    # 否则 成绩为不合格
    
    score = int(input('请输入您的成绩'))
    if score >= 90:
        print('优秀')
    elif score >= 80:
        print('良好')
    elif score >= 70:
        print('中等')
    elif score >= 60:
        print('及格')
    else:
        print('不及格')

## for循环 ##

# 格式： for 变量 in 要遍历的数据:
    # 方法体
    
    # 循环字符串
    s = 'china'
    for i in s:
        print(i)
    
    # range方法的结果 一个可以遍历的对象 
    range（起始值，结束值）	左闭右开区间
    for i in range(1,6):
        print(i)
    
    # range（起始值，结束值，步长） 左闭右开区间
    # 1 4 7 10
    for i in range(1,11,3):
        print(i)
    
    # 循环一个列表
    a_list = ['周杰伦','林俊杰','陶喆','庞龙']
    for i in a_list:
        print(i)
    
    # 判断列表中的元素的个数
    print(len(a_list))
    # 0 1 2 遍历列表中的下标
    for i in  range(len(a_list)):
        print(i)

## 字符串的高级 ##

# 获取长度:len len函数可以获取字符串的长度。
    # 查找内容:find 查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串中第一次出现的开始位置索引值，如果不存在，则返回-1.
    # 判断:startswith,endswith 判断字符串是不是以谁谁谁开头/结尾
    # 计算出现次数:count 返回 str在start和end之间 在 mystr里面出现的次数
    # 替换内容:replace 替换字符串中指定的内容，如果指定次数count，则替换不会超过count次。
    # 切割字符串:split 通过参数的内容切割字符串
    # 修改大小写:upper,lower 将字符串中的大小写互换
    # 空格处理:strip 去空格
    # 字符串拼接:join 字符串拼接
    
    s = 'china'
    print(len(s))
    print(s.find('a'))
    print(s.startswith('h'))
    print(s.endswith('n'))
    print(s.upper())
    
    s1 = 'aaabb'
    print(s1.count('b'))
    
    s2 = 'cccdd'
    print(s2.replace('c','d'))
    
    s3 = '1#2#3#4'
    print(s3.split('#'))	# 结果为：['1', '2', '3', '4']
    
    s4 = 'CHINA'
    print(s4.lower())
    
    s5 = ' a '
    print(len(s8)) # 空格算长度 结果为：7
    print(len(s5.strip()))
    
    s6 = 'a'
    print(s6.join('hello'))		# 结果为：haealalao

## 列表 ##

添加

# append 追加 在列表的最后来添加一个对象/数据
    food_list = ['铁锅炖大鹅','酸菜五花肉']
    food_list.append('小鸡炖蘑菇')
    print(food_list)
    # 结果为：['铁锅炖大鹅', '酸菜五花肉', '小鸡炖蘑菇']
    
    # insert 插入
    char_list = ['a','c','d']
    # index的值就是你想插入数据的那个下标
    char_list.insert(1,'b')
    print(char_list)
    # 结果为：['a', 'b', 'c', 'd']
    
    # extend
    num_list = [1,2,3]
    num1_list = [4,5,6]
    num_list.extend(num1_list)
    print(num_list)
    # 结果为：[1, 2, 3, 4, 5, 6]

修改

city_list = ['北京','上海','深圳','武汉','西安']
    # 将列表中的元素的值修改,可以通过下标来修改，注意列表中的下标是从0开始的
    city_list[4] = '大连'
    print(city_list)
    # 结果为：['北京', '上海', '深圳', '武汉', '大连']

查询

# in 是判断某一个元素是否在某一个列表中
    food_list = ['锅包肉','汆白肉','东北乱炖']
    
    # 判断一下在控制台输入的那个数据 是否在列表中
    food = input('请输入您想吃的食物')
    
    if food in food_list:
        print('在')
    else:
        print('不在，一边拉去')
    
    # not in
    ball_list = ['篮球','台球']
    # 在控制台上输入你喜欢的球类 然后判断是否不在这个列表中
    ball = input('请输入您喜欢的球类')
    if ball not in ball_list:
        print('不在')
    else:
        print('在')

删除

a_list = [1,2,3,4,5]
    del a_list[2]		#根据下标来删除列表中的元素
    print(a_list)
    
    b_list = [1,2,3,4,5]
    b_list.pop()	# pop是删除列表中的最后一个元素
    print(b_list)
    
    c_list = [1,2,3,4,5]
    c_list.remove(3)	# 根据元素来删除列表中的数据
    print(c_list)

## 元组 ##

a_tuple = (1,2,3,4)
    print(a_tuple[0])
    
    # 元组是不可以修改里面的内容的
    a_tuple[3] = 5	# 报错
    
    a_tuple = (5)
    print(type(a_tuple))	# 结果：<class 'int'>
    # 当元组中只要一个元素的时候 那么他是整型数据
    # 定义只有一个元素的元组，需要在唯一的元素后写一个逗号
    b_tuple = (5,)
    print(type(b_tuple))	# 结果：<class 'tuple'>

> 列表中的元素是可以修改的 而元组中的元素是不可以被修改

## 切片 ##

s ='hello world'
    print(s[0])		# 在切片中直接写一个下标
    print(s[0:4])	# 左闭右开区间 包含坐标的数据 不包含右边的数据
    print(s[1:])	# 是从起始的值开始 一直到末尾
    print(s[:4])	# 是下标为0的索引的元素开始 一直到第二参数为止 遵循左闭右开区间
    print(s[0:6:2])	# 从下标为0的位置开始 到下标为6的位置结束 每次增长2个长度
    
    # 输出结果：
    h
    hell
    ello world
    hell
    hlo

## 字典 ##

查询

# 定义一个字典
    person = { 'name':'吴签','age':28}
    
    # 访问person的name
    print(person['name'])
    
    # 使用[]的方式，获取字典中不存在的key的时候 会发生异常 keyerror
    print(person['sex'])		# 报错
    
    # 不能使用.的方式来访问字典的数据
    print(person.name)		# 报错
    print(person.get('name'))
    print(person.get('age'))
    
    # 使用.的方式，获取字典中不存在的key的时候 会返回None值
    print(person.get('sex'))

修改

person = { 'name':'张三','age':18}
    
    # 修改name的值为法外狂徒
    person['name'] = '法外狂徒'

添加

person = { 'name':'老马'}
    
    # 给字典添加一个新的key value
    # 如果使用变量名字['键'] = 数据时 这个键如果在字典中不存在 那么就会变成新增元素
    person['age'] = 18
    
    # 如果这个键在字典中存在 那么就会变成这个元素
    person['name'] = '阿马'

删除

# del
    # (1) 删除字典中指定的某一个元素
    person = { 'name':'老马','age':18}
    
    # del person['age']
    # 删除之后
    print(person)		# 结果：{'name': '老马'}
    
    # （2） 删除整个字典
    del person
    # 删除之后
    print(person)		# 结果：报错，person已不存在
    
    # clear
    # （3） 清空字典 但是保留字典对象
    # 清空指的是将字典中所有的数据 都删除掉 而保留字典的结构
    person.clear()
    print(person)		# 结果：{}

遍历

person = { 'name':'阿马','age':18,'sex':'男'}
    
    # (1) 遍历字典的key
    # 字典.keys() 方法 获取的字典中所有的key值 key是一个变量的名字 我们可以随便起
    for key in person.keys():
        print(key)
    
    # (2) 遍历字典的value
    # 字典.values()方法 获取字典中所有的value值 value也是一个变量 我们可以随便命名
    for value in person.values():
        print(value)
    
    # (3) 遍历字典的key和value
    for key,value in person.items():
        print(key,value)
    
    # (4) 遍历字典的项/元素
    for item in person.items():
        print(item)

## 文件 ##

打开或创建文件

# 创建一个test.txt文件
    # open(文件的路径,模式)
    # 模式: w 可写 r 可读
    open('test.txt','w') 	#如果文件不存在，则创建文件
    
    # 打开文件
    fp = open('test.txt','w')
    fp.write('hello world')
    
    # 文件夹是不可以创建的 暂时需要手动创建
    fp = open('demo/text.txt','w')
    fp.write('hello world')
    
    # 文件的关闭
    fp = open('a.txt','w')
    fp.write('hello')
    fp.close()

写文件

# 写数据
    # write方法
    fp = open('test.txt','a')
    fp.write('hello world,i am here\n' * 5)
    fp.close()
    
    # 如果文件存在 会先清空原来的数据 然后再写
    # 如果想在每一次执行之后都要追加数据
    # 如果模式变为了a 那么就会执行追加的操作
    
    # 读数据
    fp = open('test.txt','r')
    # 默认情况下 read是一字节一字节的读 效率比较低
    content = fp.read()
    print(content)
    
    # readline是一行一行的读取 但是只能读取一行
    content = fp.readline()
    print(content)
    
    # readlines可以按照行来读取 但是会将所有的数据都读取到 并且以一个列表的形式返回
    # 而列表的元素 是一行一行的数据
    content = fp.readlines()
    print(content)

文件序列化：json的dumps、dump、loads、load方法

fp = open('test.txt','w')
    # 默认情况我们只能将字符串写入到文件中
    fp.write('hello world')
    fp.close()
    
    fp = open('test.txt','w')
    # 默认情况下,对象是无法写入到文件中 如果想写入到文件 那么必须使用序列化操作
    name_list = ['zhangsan','lisi']
    fp.write(name_list)	# 结果：报错。write方法参数必须是个字符串
    
    # 序列化的2种方式
    # 方式一：dumps()
    fp = open('test.txt','w')
    name_list = ['zs','ls']
    # 导入json模块到该文件中
    import json
    # 序列化：将python对象 变成 json字符串
    names = json.dumps(name_list)
    # 将names写入到文件中
    fp.write(names)
    fp.close()
    
    
    # 方式二：dump 在将对象转换为字符串的同时，指定一个文件的对象 然后把转换后的字符串写入到这个文件里
    fp = open('text.txt','w')
    name_list = ['zs','ls']
    import json
    # 相当于 names = json.dumps(name_list) 和 fp.write(names)
    json.dump(name_list,fp)
    fp.close()
    
    # 反序列化：将json的字符串变成一个python对象
    fp = open('text.txt','r')
    content = fp.read()
    # 读取之后 是字符串类型的
    # loads方法：方法参数是读到的内容
    import json
    # 将json字符串变成python对象
    result = json.loads(content)
    # 转换之后
    print(type(result))
    
    # load 方法：方法参数是打开的文件
    fp = open('text.txt','r')
    import json
    result = json.load(fp)
    print(result)
    fp.close()

> dumps、dump、loads、load的区别

## 异常 ##

# 异常的格式
    # try:
    # 可能出现异常的代码
    # except 异常的类型
    # 友好的提示
    
    try:
        fp = open('text.txt','r')
        fp.read()
    except FileNotFoundError:
        print('系统正在升级，请稍后再试。。。')