Python

XUN~MLF

已于 2022-06-08 12:32:17 修改

阅读量2.4k

点赞数

文章标签： python 开发语言后端

于 2022-01-14 11:38:35 首次发布

本文链接：https://blog.csdn.net/XUN__MLF/article/details/122490717

版权

简介

python简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
**Python 是初学者的语言：**Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

python发展史

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。

Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。

像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。

现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。

Python 2.7 被确定为最后一个 Python 2.x 版本，它除了支持 Python 2.x 语法外，还支持部分 Python 3.1 语法。

python特点

**1.易于学习：**Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
**2.易于阅读：**Python代码定义的更清晰。
**3.易于维护：**Python的成功在于它的源代码是相当容易维护的。
**4.一个广泛的标准库：**Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
**5.互动模式：**互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
**6.可移植：**基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
**7.可扩展：**如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
**8.数据库：**Python提供所有主要的商业数据库的接口。
**9.GUI编程：**Python支持GUI可以创建和移植到许多系统调用。
10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力

基础语法

注释

# 单行注释
""" 多行注释 """
''' 多行注释 '''

输出语句

# 可以输出数字
print(520)
print(98.5)

# 可以输出字符串
print("helloworld")
print('helloworld')

# 含有运算符的表达式
print(3 + 1)

# 将数据输出到文件中
# 所指定盘所存在的位置 ，使用 file=fp ,a+ 表示如果没有该文件就创建一个文件，如果有该文件就添加到该文件中
fp = open('D:/text.txt', 'a+')
print('helloworld', file=fp)
fp.close()

# 不进行换行输出
print('java', 'python', 'c++')

转义字符

# 转义字符
print('hello\nworld')  # \n 换行
print('hello\tworld')  # \t 水平制表符
print('hello\rworld')  # \r world将hello覆盖
print('hello\bworld')  # \b 表示退一个格

print('http://www.baidu.com')
print('老师说:\'大家好\'')

常见数据类型

# int bool str float
# 整数可以表示各个进制
print('十进制', 110)
print('二进制', 0b1000101010)
print('八进制', 0o176)
print('十六进制', 0x16EF5)

浮点型

from decimal import Decimal

# 浮点类型
a = 3.141592654
print(a, type(a))

n = 1.1
m = 2.2
print(n + m)
print(Decimal('1.1') + Decimal('2.2'))

字符串

# 字符串类型
str1 = 'python你好'
print(str, type(str))

bool类型

# bool类型
f1 = True
f2 = False
print(type(f1), type(f2))
print(f1 + 1)
print(f2 + 1)

数据类型转换

name = '张三'
age = 18
print(type(age), type(name))
print('我叫' + name + '今年' + str(age) + '岁')  # 将str类型与int类型进行连接时，要进行类型转换

input函数

pre = input('你想要什么生日礼物呢？')  # input函数输入的是字符串类型
print(pre, type(pre))

a = input("请输入一个数:")
b = input("请输入一个数:")
print(int(a) + int(b))

运算符

print(11 / 2)  # 除法运算
print(11 // 2)  # 整除运算
print(11 % 2)  # 求余
print(2 ** 3)  # 幂运算
"""
=  表示赋值运算符

== 称为比较运算符，比较的是两个对象的value值

is 比较对象的标识(id)

"""
a = 10
b = 10
print(a == b)
print(a is b)

条件运算

money = 1000
s = int(input("请输入取款金额:"))
if money >= s:
    money -= s
    print('取款成功，余额为:', money)
else:
    print("您的余额不足！请充值！")

m = int(input("请输入一个成绩"))
if 90 <= m <= 100:  # m>=90 and m<=100
    print('A')
elif 60 <= m <= 89:
    print('B')
else:
    print("D")

pass语句

# pass语句，就是表示一个占位符

answer = input("您是会员吗?:Y/N")
if answer == 'Y':
    pass
else:
    pass

range函数

r = range(10)
print(r)
print(list(r))

r = range(1, 10)
print(r)
print(list(r))

r = range(1, 10, 2)
print(r)
print(list(r))


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

循环

# python中没有自增 不能i++  ，i--
i = 1
while i < 10:
    print(i)
    i += 1

##################
i = 1
sum = 0
while i <= 100:
    if i % 2 == 0:
        sum += i
    i += 1
print("100以内的偶数和:", sum)

#############

for item in 'python':
    print(item)

for i in range(10):
    print(i)

sun = 0
for i in range(1, 101):
    if i % 2 == 0:
        sun += i
print("100以内的偶数和:", sun)

水仙花数

for item in range(100, 1000):
    ge = item % 10
    shi = item // 10 % 10
    bai = item // 100
    if ge ** 3 + shi ** 3 + bai ** 3 == item:
        print(item)

乘法口诀表

for i in range(1, 10):
    for j in range(1, i + 1):
        print(i, '*', j, "=", i * j, "", end="\t")
    print("")

print("-------------------------------")

i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(i, '*', j, "=", i * j, "", end="\t")
        j += 1
    print()
    i += 1

break和continue

# continue 语句跳出本次循环，而break跳出整个循环。

for item in range(8):
    pwd = input("请输入密码:")
    if pwd == "8888":
        print('密码正确')
        break
    else:
        print("密码错误")

for item in range(2):
    pwd = input("请输入密码:")
    if pwd == "8888":
        print('密码正确')
        continue
    else:
        print("密码错误")

数据结构

'''

数据结构        是否可变    是否重复      是否有序       定义符号
列表(list)       可变      可重复         有序          []

元组(tuple)      不可变    可重复         有序          ()

字典(dict)       可变       key可以      无序          {key: value}
                          value不行

集合(set)        可变      不可重复       无序           {}
'''

列表

简介

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

案例

# 列表 list
lsr = ['hello', 'world', 98, "你好"]
print(lsr)
print(lsr[0])
print(lsr.index('hello'))  # 如果列表中存在多个相同元素，只返回第一个元素的索引

通过索引获取列表中的元素

lst = ["hello", "world", 98, "你好"]
# 获取索引为2的元素
print(lst[2])

# 获取索引为-3的元素
print(lst[-3])

获取列表中的多个元素（切片）

lst = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
"""
切片操作
格式：lst[start:stop:step]
范围 ：[start,stop)
step默认为 1
"""
# start=1,stop=6,step=1   索引
print(lst[1:6:1])
print(lst[1:6])  # 默认step=1
print(lst[1:6:])

# start=1,stop=6,step=2
print(lst[1:6:2])
print(lst[:6:2])  # start采用默认值
print(lst[1::2])  # stop采用默认值

print("-------------------------------------------")
# step 为负数的情况 就是逆序输出
print(lst[::-1])
print(lst[7::-1])

print("hello" in lst)
print(90 in lst)
print("99" not in lst)

print("----------------------列表的遍历---------------------")
for item in lst:
    print(item)

对列表元素进行CRUD

print("---------------------添加操作---------------------")
lst = [10, 20, 30]
print("添加之前：", lst, id(lst))
lst.append(100)  # append() :向该列表的末尾添加一个元素
print("添加之后：", lst, id(lst))
lst2 = ["hello", "world"]
# lst.append(lst2)   将lst2作为一个元素添加到列表的末尾
lst.extend(lst2)  # extend() 向列表的末尾至少添加一个元素
print(lst)

# 在任意位置上添加一个元素
lst.insert(1, "python")
print(lst)

# 切片  就是将索引是1 以后的元素用新的列表去替换
lst3 = ["你好", "how are you", "fine"]
lst[1:] = lst3
print(lst)
print()

print("---------------------删除操作---------------------")
str1 = [10, 20, 30, 40, 50, 60, 30]
str1.remove(30)  # 从列表中移除一个元素,如果有重复元素，只移除第一个
print(str1)
# pop() 根据索引移除元素
str1.pop(1)
print(str1)
str1.pop()  # 如果不指定索引，将删除列表中的最后一个元素
print(str1)

# 切片删除，将产生一个新的列表对象
new_list = str1[1:3]
print("原列表", str1)
print("切片后列表", new_list)
# 不产生新的列表，而是删除原列表中的内容
str1[1:3] = []
print(str1)
# 清除列表中的所有元素
str1.clear()
print(str1)
# del语句将列表对象删除
del str1
# print(str1)

print("---------------------修该操作---------------------")
st = [10, 20, 30, 40, 50, 60, 30]
st[2] = 100
print(st)
st[1:3] = [200, 300, 400]
print(st)

列表元素排序

st = [12, 56, 25, 14, 1254]
print("排序前的列表", st)

st.sort()  # 升序
print("排序后的列表(升序)", st)

st.sort(reverse=True)
print("排序后的列表(降序)", st)

# 使用sorted函数
st1 = [12, 56, 25, 14, 1254]
new_lst = sorted(st1)
print(new_lst)

desc_st = sorted(st1, reverse=True)
print(desc_st)

列表生成式

lst = [item for item in range(1, 10)]
print(lst)

lst = [item*item for item in range(1, 10)]
print(lst)

元组

简介

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

基本操作

"""
不可变序列：没有增、删、改操作
         字符串，元组

可变序列: 可执行增、删、改操作，对象地址不发生改变
        列表，字典
"""

# 元组  tuple
'''元组的创建方式'''
# 第一种方式 （）

t = ('python', 'hello', 'world', 98)
print(t)
print(type(t))

t = 'python', 'hello', 'world', 98  # 这种方式下小括号可以省略不写
print(t)
print(type(t))

# 第二种创建方式 使用内置函数 tuple()
t1 = tuple({'python', 'hello', 'world', 98})
print(t1)
print(type(t1))

# ！！！ 注意
# 如果一个元组中包含一个元素，需要使用小阔号和逗号，  逗号不能少
t2 = (20,)
print(t2)
print(type(t2))

t2 = ("你好")
print(t2)
print(type(t2))

# 空列表
lst = []
lst1 = list()
print("空列表:", lst, lst1)

# 空字典
d = {}
d2 = dict()
print("空字典:", d, d2)

# 空元组
t = ()
t1 = tuple()
print("空元组:", t, t1)



# 元组遍历
t = ('python', 'hello', 'world', 98)

for item in t:
    print(item)

字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

创建字典

# dict
# 使用 {} 创建字典
scope = {"name": "李四", "age": 18}
print(scope)
print(type(scope))

# dict() 创建字典python
student = dict(name='jack', age=18)
print(student)

字典元素操作

''' 获取字典的元素 '''
scope = {'张三': 89, '李四': 86, '赵六': 66}
# 第一种方式 使用[]
print(scope['张三'])
# print(scope['张']) 如果字典中没有该元素会报错

# 第二种方式使用get()方法
print(scope.get('张三'))
print(scope.get('张'))  # 字典中没有该元素会报 none

print(scope.get('张', 100))  # 字典用没有该元素是，自定义元素去替换

print('-------------key的判断---------------')
print("张三" in scope)
print("张三" not in scope)

print('-------------字典元素的删除---------------')
del scope['张三']
# scope.clear() 清空字典的元素
print(scope)

scope['ning'] = 88  # 新增元素
print(scope)

scope['ning'] = 100  # 修该元素
print(scope)

获取字典视图的三种方式

scope = {'张三': 89, '李四': 86, '赵六': 66}
keys = scope.keys()
print(keys)
print(type(keys))
print(list(keys))  # 将key组成的视图转为列表

# 获取所有的 value
values = scope.values()
print(values)
print(type(values))
print(list(values))

# 获取所有的键值对 key-value
items = scope.items()
print(items)
print(list(items))

字典遍历

scope = {'张三': 89, '李四': 86, '赵六': 66}

for items in scope:
    print(items, scope.get(items))

字典生成式

items = ['fruit', 'books', 'other']
price = [50, 60, 70, 80, 90]
d = {items: price for items, price in zip(items, price)}
print(d)

集合

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

集合的创建

'''第一种创建集合的方式'''
s = {1, 2, 3, 5, 5, 6, 7, 7, 8}  # 集合中的元素不允许重复，重复元素只会出现一次
print(s)

"""第二种创建方式 set()"""

s1 = set(range(6))
print(s1, type(s1))

# 将列表转成集合
s2 = {1, 2, 2, 3, 4, 5, 5, 6, 4}
print(s2, type(s2))

s3 = set((6, 2, 5, 6, 124))
print(s3, type(s3))  # {2, 124, 5, 6} <class 'set'>  集合中的元素是无序的

s4 = set('python')
print(s4, type(s4))  # {'o', 't', 'p', 'h', 'y', 'n'} <class 'set'>

# 定义一个空集合
s5 = set()
print(s5, type(s5))

集合元素的相关操作

s = {10, 20, 30, 4, 5, 0, 60, 121}
print(s)
# 集合中元素的判断
print(10 in s)
print(100 not in s)

# 集合元素的新增操作
s.add(40)
print(s)
s.update({300, 400, 500})
print(s)
print(len(s))

# 集合元素的删除
s.remove(10)
print(s)
s.discard(100)
print(s)
s.pop()  # 随意删除一个元素
print(s)
s.clear()
print(s)

集合元素之间的关系

'''两个集合是否相等  元素相同就相等'''
s = {10, 20, 30, 40}
s1 = {30, 20, 10, 40}
print(s == s1)
print(s1 != s)

"""一个集合是否是另一个集合的子集"""
s1 = {10, 20, 30, 40, 50}
s2 = {10, 20, 30}
s3 = {20, 90}
print(s2.issubset(s1))
print(s3.issubset(s1))
# 超集
print(s1.issuperset(s2))
print(s1.issuperset(s3))

# 两个集合是否含有交集
print(s2.isdisjoint(s3))  # 有交集为 False

集合元素的数学操作

# 数学交集
s1 = {10, 30, 50, 60, 80, 40}
s2 = {20, 30, 60, 90}
print(s1.intersection(s2))
print(s1 & s2)

# 并集操作
print(s1.union(s2))
print(s1 | s2)

# 差集操作
print(s1.difference(s2))
print(s1-s2)

# 对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)

集合生成式

# 列表生成式
ls = [i * i for i in range(6)]
print(ls, type(ls))

# 集合生成式
s = {i * i for i in range(6)}
print(s, type(s))

# 字典生成式
items = ['fruit', 'books', 'other']
price = [50, 60, 70, 80, 90]
d = {items: price for items, price in zip(items, price)}
print(d, type(d))

# 元组没有生成式

字符串操作

字符串的驻留机制

"""

驻留机制: 仅保存一份相同且不可变字符串的方法
驻留机制的几种情况 ：字符串长度为0或1时
符合标识符的字符串
字符串只在编译时驻留
[-5,256]之间的整数数字

驻留的优缺点：当需要值值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁。提升效率和节约内存，



"""
a = 'python'
b = "python"
c = '''python'''
print(a)
print(b)
print(c)

字符串的常用操作

a = 'hello,python'
s = a.upper()  # 转成大写，转换之后会产生一个新的字符串对象
d = a.lower()  # 转小写，转换之后会产生一个新的字符串对象
print(a, id(a))
print(s, id(s))
print(d, id(d))

s2 = 'hello.Python'
print(s2.swapcase())  # 原来小写变大写，大写变小写

print(s2.title())  # 把每个单词第一个字母转换为大写，其余字母为小写
print(s2.capitalize()) # 把第一个字符变成大写，其余的为小写

内容对齐

s = 'hello,python'
'''居中对齐'''
print(s.center(20, '*'))

'''左对齐'''
print(s.ljust(20, '*'))
print(s.ljust(10))
print(s.ljust(20))

'''右对齐'''
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))

'''右对齐，使用0填充'''
print(s.zfill(20))

字符串分割

s = 'hello world python'
lst = s.split()  # 从字符串左边开始劈分，默认劈分字符是空格，返回的值都是一个列表
print(lst)

s2 = 'hello|world|python'
print(s2.split(sep='|'))  # 指定分隔符
print(s2.split(sep='|', maxsplit=1))

'''rsplit() 从右测开始劈分'''
s2 = 'hello|world|python'
print(s.rsplit())
print(s2.rsplit('|'))
print(s2.rsplit('|', maxsplit=1))

判断字符串的操作

s = 'hello,python'
print('1', s.isidentifier())  # isidentifier() 判断字符是不是合法的标识符
print('2', 'hello'.isidentifier())
print('3', '张三_'.isidentifier())
print('4', '_211'.isidentifier())

print('5', '\t'.isspace())  # isspace() 判断字符串是否全部由空白字符组成（回车 换行 水平制表符）

print('6', 'abc'.isalpha()) # isalpha() 判断字符串是否全部由字母组成
print('7', '张三'.isalpha())
print('8', '张三1'.isalpha())


print('9',  '123'.isdecimal()) # isdecimal() 判断字符串是否全部由十进制的数字构成
print('10', '123四'.isdecimal())

print('11', '123'.isnumeric()) # isnumeric() 判断字符串是否由由数字组成
print('12', '123四'.isnumeric())

print('13', '123四'.isalnum()) # isalnum() 判断指定字符串是否全部由数字字母组成
print('14', '123四qqq'.isalnum())
print('15', '张三qqq'.isalnum())
print('16', '张三！qqq'.isalnum())

字符串的合并与替换

s = 'hello,python'
print(s.replace('python', 'java'))  # 字符串的替换，第一个参数指定被替换的字符，第二个参数将要替换成的字符，第三个参数替换个数

s = 'hello,python,python,python'
print(s.replace('python', 'java', 2))


lst = ['hello', 'python', 'java']
print('|'.join(lst))
print(''.join(lst))

t = ('hello', 'python', 'java')
print(''.join(t))

print('*'.join('python'))

字符串的比较

'''
== 与 is 的与别
== 比较的是value
is 比较的是id是否相等

'''

字符串切片

s = 'hello,python'
s1 = s[:5]
s2 = s[6:]
s3 = '!'
new_str = s1+s3+s2
print(s1)
print(s2)
print(new_str)

格式化字符串

# 格式化字符串

# 第一种 % 占位符
name = '张三'
age = 18
print('我叫%s,今年%s岁' % (name, age))
print('%10d' % 99 ) # % 表示宽度
print('%.3f' % 3.141592654) # .3 表示精度
print('%10.3f' % 3.141592654) # 同时表示宽度和精度

# 第二种 使用{} 结合format 方法
print('我叫{0}，今年{1}'.format(name, age))
print('{0:.3}' . format(3.1415926)) # .3 表示一共三位数
print('{0:.3f}' . format(3.1415926)) # .3f 表示3为小数
print('{0:10.3f}' . format(3.1415926))


# 3 f-string
print(f'我叫{name},今年{age}')

字符串的编码转码

s = '天涯共此时'
# 编码
print(s.encode(encoding='GBK')) # 在GBK编码格式中，一个中文占两个字节
print(s.encode(encoding='UTF-8')) # 在UTF-8编码格式中，一个中文占三个字节


# 解码
byte = s.encode(encoding='GBK') # 编码

函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

函数的创建

# 函数的创建
def asc(a, b):  # a,b 称为形式参数，形参的位置在函数的定义处
    c = a + b
    return c


# 函数的调用
result = asc(10, 20)  # 10， 20 成为实际参数的值，实参的位置在函数的调用出
print(result)

# 关键字传参
res = asc(b=10, a=20)  # 根据形参的名字进行参数传递
print(res)

函数的参数传递

def fun(arg1, arg2):
    print('arg1', arg1)
    print('arg2', arg2)
    arg1 = 100
    arg2.append(10)
    print('arg1', arg1)
    print('arg2', arg2)


n1 = 11
n2 = [22, 33, 44]
print('n1', n1)
print('n2', n2)
fun(n1, n2)   # 实参名称可以和形参名称不一样
print()
print('n1', n1)  # 你n1为不可变对象，在函数体的修该不会影响实参的值 arg1的修该不会永影响 n1的值
print('n2', n2)


'''
总结：在函数调用的过程中，进行参数的传递，
如果是不可变对象，在函数体的修该不会影响实参的值
如果是可变对象，在函数体的修该会影响实参的值

'''

函数的返回值

def fun(num):
    odd = []
    even = []
    for i in num:
        if i % 2:
            odd.append(i)
        else:
            even.append(i)
    return odd, even

# 函数的调用
lis = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(fun(lis))
'''
函数的返回值
1）：如果函数没有返回值【函数执行完毕之后，不需要给调用出提供数据】，return可以省略不写
2）：函数的返回值是1，直接返回类型
3）：函数的返回值，如果是多个，返回的结果为元组

'''

函数的默认值

def fun(a,b=10): # b称为默认值参数
    print(a,b)

fun(100)
fun(20,30)

函数的参数定义

def fun(*args): #使用 *参数名：表示可变的位置参数，结果为一个元组，函数中的形参只能有一个
    print(args)


fun(10)
fun(10, 20, 30)
fun(10, 20, 30, 40, 50)


def fun1(**z): # **变量名：个数可变的关键字参数，结果是一个字典，函数中的形参只能有一个
    print(z)

fun1(a=10)
fun1(a=10,b=20,c=30)

函数的参数传递

def fun(a, b, c):
    print('a=', a)
    print('b=', b)
    print('c=', c)


fun(10, 20, 30)  # 函数调用时的参数传递，成为位置传参
print()
lst = [11, 22, 33]  # 函数传递时，将列表中的每个元素转换为位置实参传入
fun(*lst)

print('----------------')
fun(a=100, b=300, c=500)  # 函数的调用，关键字实参
dic = {'a': 12, 'b': 33, 'c': 55}
fun(**dic)  # 在函数调用时，将字典中的键值对转换为关键字实参传入

变量的作用域

def fun(a, b):
    c = a + b  # c 称为局部变量，作用范围在函数的内部
    print(c)


fun(10, 20)

name = '仰' # 全局使用---全局变量
print(name)


def fun2(name):
    print(name)

递归函数

a = int(input("请输入一个整数:"))
def fun(a):
    if a == 1:
        return 1
    else:
        return a * fun(a - 1) # 函数递归调用

python
print("{0}的阶乘为:{1}".format(a, fun(a)))

斐波那契数列

def fun(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fun(n - 1) + fun(n - 2)


# 斐波那契数列第6位的数字
print(fun(6))

# 输出这个斐波那契数列
for i in range(1, 7):
    print(fun(i), end="\t")

学生信息管理系统

# @Time    : 2021/10/13 14:37
# @Author  : XUN~MLF
# @File    : 学生信息管理系统.py
# @Software: PyCharm

import time

student_list = []  # 创建一个列表，用于存储学生信息


# 主函数
def main():
    while True:
        menu()
        print()
        choice = int(input("请输入你要进行操作的编号:"))
        if choice in [1, 2, 3, 4, 5, 6]:
            if choice == 1:
                insert()
            elif choice == 2:
                delete()
            elif choice == 3:
                update()
            elif choice == 4:
                select()
            elif choice == 5:
                show()
            elif choice == 6:
                result = input("你确定要退出系统吗?Y/N:")
                if result == 'Y' or result == 'y':
                    print("退出系统成功")
                    print("谢谢使用！")
                    break
                else:
                    continue


# 主菜单
def menu():
    print('=' * 50)
    print('\t学生管理系统-函数版')
    print('\t1、增加insert-个人信息')
    print('\t2、删除delete-个人信息')
    print('\t3、修该update-个人信息')
    print('\t4、查询select-个人信息')
    print('\t5、显示所有学生信息')
    print('\t6、退出系统')
    print('=' * 50)


# 1、添加学生
def insert():
    global student_list  # 声明全局变量
    name = input('请输入学生姓名:')
    age = int(input('请输入学生年龄(18-25):'))
    while True:
        if age < 18 or age > 25:
            age = int(input('请输入学生年龄(18-25):'))
        else:
            break
    tel = input('请输入学生电话:')
    while True:
        if len(tel) < 11:
            tel = input("输入的电话号码长度小于11位，请重新输入:")
            continue
        if len(tel) > 11:
            tel = input("输入的电话号码长度大于11位，请重新输入:")
            continue
        else:
            break

    # 获取当前时间
    now_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    # 定义一个字典，存放单个学生信息
    student = {'name': name, 'age': age, 'tel': tel, 'registime': now_time}
    # 单个学生信息放入列表
    student_list.append(student)
    print(student_list)
    print("学生添加成功！")


# 2、删除学生
def delete():
    delName = input('请输入要删除学员姓名:')
    for stu in student_list:
        if delName == stu['name']:
            student_list.remove(stu)
            print("删除成功！")
            break
        else:
            print("未找到该学生，删除失败")
            break
    print('删除后学生信息', student_list)


# 3、修该学生
def update():
    updateName = input('请输入要修改学生姓名:')
    for stu in student_list:
        if updateName == stu['name']:
            stu['name'] = input('修该后的学生姓名:')
            stu['age'] = int(input('修改后的学生年龄:'))
            while 1:
                if stu['age'] < 18 or stu['age'] > 25:
                    stu['age'] = int(input('请输入学生年龄(18-25):'))
                else:
                    break
            stu['tel'] = input('修改后的学生电话:')
            while True:
                if len(stu['tel']) < 11:
                    stu['tel'] = input("输入的电话号码长度小于11位，请重新输入:")
                    continue
                if len(stu['tel']) > 11:
                    stu['tel'] = input("输入的电话号码长度大于11位，请重新输入:")
                    continue
                else:
                    break

            stu['registime'] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            print('修该成功！')
            break
        else:
            print("未找到该学生，修该失败！")
            break
    print('修该后的学生信息:', student_list)


# 4、查询学生
def select():
    selectName = input('请输入要查找学生姓名')
    for stu in student_list:
        if selectName == stu['name']:
            print('查询到的学生信息:', stu)
            break
        else:
            print("未找到该学生，查询失败")
            break


# 5、显示所有学生信息
def show():
    print('所有学生信息如下:')
    for students in student_list:
        print('学生姓名:', students['name'], ',', '学生年龄:', students['age'], ',', '学生电话:', students['tel'], ',', '学生注册时间:',students['registime'])


if __name__ == '__main__':
    main()

类

类的定义

def drink():  # 在类之外定义的称为函数，在类之内定义的称为方法
    print('喝水')


class Student:
    address = '吉林'  # 直接x写在类里面的变量，称为类属性

    # 构造方法
    def __init__(self, name, age):
        self.name = name  # self.name称为实体属性，进行了一个赋值操作，将局部变量的name值赋值给实体属性
        self.age = age

    # 实例方法
    def eat(self):
        print('好好吃饭')

    # 静态方法
    @staticmethod  # 静态方法，使用staticmethod进行修饰
    def method():
        print('我使用了静态方法')

    # 类方法，
    @classmethod  # 类方法，使用classmate进行修饰
    def cm(cls):
        print('我是类方法，')


stu = Student('zhagnsan', 18)
stu.eat()

封装

class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age # 年龄不希望在类的外部被使用，所以加了两个__

    def show(self):
        print(self.name, self.__age)


stu = Student('张三', 19)
stu.show()
# 在类的外部使用name和age
print(stu.name)
# print(stu.__age)
print(dir(stu))
print(stu._Student__age) # 在类的外部可以通过 _Student__age 进行访问

继承

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


class Student(Person):
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no


class Teacher(Person):
    def __init__(self, name, age, year):
        super().__init__(name, age)
        self.year = year


stu = Student('zhang', 18, '1001')
ter = Teacher('liu', 29, 5)
stu.info()
ter.info()

print('------python中可以多继承--------------------')


class A(object):
    pass


class B(object):
    pass


class C(A, B):
    pass

方法重写

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


class Student(Person):
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no
    def info(self):
        super().info()
        print(self.stu_no)


class Teacher(Person):
    def __init__(self, name, age, year):
        super().__init__(name, age)
        self.year = year


stu = Student('zhang', 18, '1001')
ter = Teacher('liu', 29, 5)
stu.info()
ter.info()

多态

class Animal(object):
    def eat(self):
        print('动物会吃')


class Dog(Animal):
    def eat(self):
        print('狗吃骨头')


class Cat(Animal):
    def eat(self):
        print('猫吃鱼。。。')


class Person:
    def eat(self):
        print('人吃五谷杂粮')


# 定义一个函数
def fun(obj):
    obj.eat()


fun(Cat())
fun(Dog())
fun(Animal())
fun(Person())

object类

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return '我的名字是{0}，今年{1}岁'.format(self.name, self.age)


stu = Student('张三', 18)
print(dir(stu))
print(stu)

异常处理

异常处理机制

try:
    a = int(input("请输入一个整数："))
    b = int(input("请输入一个整数："))
    result = a/b
    print('结果为',result)
except ValueError:
    print('只能是整数')

except ZeroDivisionError:
    print('除数不能为0')
print('程序结束')

try:
    a = int(input("请输入一个整数："))
    b = int(input("请输入一个整数："))
    result = a/b
except BaseException as e:
    print('出错了')
    print(e)
else:
    print('计算结果为:',result)
finally: # 不管是否有异常都会执行
    print('谢谢执行')

文件操作（File）

open() 方法

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

**注意：**使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode='r')

完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（Python 3 不支持）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

file 对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

序号	方法及描述
1	file.close()关闭文件。关闭后文件不能再进行读写操作。
2	file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next()Python 3 中的 File 对象不支持 next() 方法。返回文件下一行。
6	[file.read(size])从文件读取指定的字节数，如果未给定或为负则读取所有。
7	[file.readline(size])读取整行，包括 “\n” 字符。
8	[file.readlines(sizeint])读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	[file.seek(offset, whence])移动文件读取指针到指定位置
10	file.tell()返回文件当前位置。
11	[file.truncate(size])从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
12	file.write(str)将字符串写入文件，返回的是写入的字符长度。
13	file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

文件读写操作

file = open('b.txt', 'w')
file.write('hello')
file.close()

file = open('b.txt', 'r')
print(file.readlines())
file.close()


file = open('b.txt', 'r')
# print(file.read())
# print(file.readline())
print(file.readlines())

print("--------------------")
file = open('c.txt', 'a')
lst = ['java', 'go', 'js']
file.writelines(lst)
file.close()

with的使用

with open('b.txt','r') as file:  # with语句，可以不用手动关闭
    print(file.read())
    
    

with open("E:/temp/" + f"{save_name}.jpg", "wb") as f:
            # 使用write()将图片写入
            f.write(picture)

OS 文件/目录方法

os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

序号	方法及描述
1	os.access(path, mode) 检验权限模式
2	os.chdir(path) 改变当前工作目录
3	os.chflags(path, flags) 设置路径的标记为数字标记。
4	os.chmod(path, mode) 更改权限
5	os.chown(path, uid, gid) 更改文件所有者
6	os.chroot(path) 改变当前进程的根目录
7	os.close(fd) 关闭文件描述符 fd
8	os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9	os.dup(fd) 复制文件描述符 fd
10	os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
11	os.fchdir(fd) 通过文件描述符改变当前工作目录
12	os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13	os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14	os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15	os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16	os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17	os.fstat(fd) 返回文件描述符fd的状态，像stat()。
18	os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19	os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
20	os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21	os.getcwd() 返回当前工作目录
22	os.getcwdb() 返回一个当前工作目录的Unicode对象
23	os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24	os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25	os.lchmod(path, mode) 修改连接文件权限
26	os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
27	os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
28	os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
29	os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30	os.lstat(path) 像stat(),但是没有软链接
31	os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32	os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
33	[os.makedirs(path, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34	os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35	[os.mkdir(path, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36	[os.mkfifo(path, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
37	[os.mknod(filename, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38	[os.open(file, flags, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
39	os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40	os.pathconf(path, name) 返回相关文件的系统配置信息。
41	os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42	os.popen(command[, mode[, bufsize]]) 从一个 command 打开一个管道
43	os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44	os.readlink(path) 返回软链接所指向的文件
45	os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46	os.removedirs(path) 递归删除目录。
47	os.rename(src, dst) 重命名文件或目录，从 src 到 dst
48	os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
49	os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50	os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51	[os.stat_float_times(newvalue]) 决定stat_result是否以float对象显示时间戳
52	os.statvfs(path) 获取指定路径的文件系统统计信息
53	os.symlink(src, dst) 创建一个软链接
54	os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55	os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56	os.tempnam([dir[, prefix]]) Python3 中已删除。返回唯一的路径名用于创建临时文件。
57	os.tmpfile() Python3 中已删除。返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58	os.tmpnam() Python3 中已删除。为创建一个临时文件返回一个唯一的路径
59	os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
60	os.unlink(path) 删除文件路径
61	os.utime(path, times) 返回指定的path文件的访问和修改的时间。
62	[os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])]输出在文件夹中的文件名通过在树中游走，向上或者向下。
63	os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
64	os.path 模块获取文件的属性信息。
65	os.pardir() 获取当前目录的父目录，以字符串形式显示目录名。

文件的备份

import os
import time

name = input('请输入要备份的文件名称:')
# 读文件
oldFile = open(name, 'r')
tol = oldFile.read()
print(tol)

listName = []
# 获取文件前缀名
for fileName in os.listdir():
    if os.path.splitext(fileName)[1] == '.txt':
        fileName = os.path.splitext(fileName)[0]
        listName.append(fileName)

# 新的文件名
newFile = listName[0] + time.strftime("%Y-%m-%d", time.localtime()) + '.txt'

# 文件备份 ,
file = open(newFile, 'w')
file.write(tol)
oldFile.close()
file.close()
print("备份前的文件名:", name)
print("备份后的文件名:", newFile)

Numpy

菜鸟教程：https://www.runoob.com/numpy/numpy-array-attributes.html

一维数组

import numpy as np

print(np.version.version)  # 查看版本号

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)

二维数组

import numpy as np

arr1 = np.array([1, 2, 3], dtype=np.int64)
print(arr1.dtype)

arr2 = np.array([1, 2, 3])
print(arr2.dtype)  # 查看数据类型

# 创建多维矩阵
arr3 = np.ones((3, 3))  # 创建全为1的数组
print(arr3)

arr4 = np.zeros((3, 3))  # 全为0的数组
print(arr4)

arr5 = np.full((3, 4), 4)  # 创建全为4 的3行4列的数组
print(arr5)

arr6 = np.random.random((4, 4))  # 创建随机矩阵
print(arr6)

arr7 = np.identity(4)  # 创建单位矩阵
print(arr7)

h = np.arange(10, 20, 2)  # 递增或递减的多维数组
print(h)

i = np.arange(12).reshape(3, 4)  # 一维数组转化成多维数组
print(i)

g = np.linspace(1, 10, 5)  # 创建一维数组且分为几段
print(g)  # [ 1.    3.25  5.5   7.75 10.  ]

内置方法

import numpy as np

arr = np.arange(16).reshape(4, 4)

print(arr, arr.shape)  # 几行几列

print(arr.ndim)  # 几维数组

print(arr.size)  # 一共有几个元素

基本运算

import numpy as np

k1 = np.array([10, 20, 30, 40])
k2 = np.arange(4)
print(k2)
print(k1 + k2)
print(k1 - k2)
print(k2 < 2)

矩阵运算

import numpy as np
import random

arr1 = np.array([[1, 1], [0, 1]])
arr2 = np.arange(4).reshape(2, 2)
print(arr2)

arr12 = arr1 * arr2  # 对应的元素相乘
print(arr12)

arr1_dot_arr2 = arr1.dot(arr2)  # 正常的矩阵相乘运算
print(arr1_dot_arr2)

print("*" * 30)
print()

# 矩阵的一些方法
M = np.random.random((2, 4))
print(M)
print(np.sum(M))
print(np.sum(M, axis=1))  # 行的求和
print(np.sum(M, axis=0))  # 列的求和

print("最小值min:", np.min(M))
print("最小值max:", np.max(M))
print("中位数:", np.mean(M))
print("平均数:", np.average(M))

# 转置
L1 = np.arange(4).reshape(2, 2)
print(L1)
print("转置:", np.transpose(L1))
print("转置:", L1.T)
print(np.argmax(L1))  # 找出最大索引

# 矩阵运算

L3 = np.arange(16).reshape(4, -1)
print(L3)
print("取出对角线的元素:", np.diag(L3))
print("由一维数组构成的方阵:", np.diag(np.array([5, 15, 25])))

L4 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(np.linalg.eig(L4))  # 计算方阵的特征根和特征向量

矩阵的索引

import numpy as np

N = np.arange(3, 15)
print(N)
print("索引值:", N[3])

N2 = np.arange(3, 15).reshape(3, 4)
print(N2)
# 用索引来看矩阵中的值
print(N2[2][1])
print(N2[1, 1:3])

# 矩阵中迭代器中的值
print(N2.flatten())
for i in N2.flatten():
    print(i, end=" ")

矩阵的合并与切片

import numpy as np

arr1 = np.array([1, 1, 1])
arr2 = np.array([2, 2, 2])
# 纵向合并
arr3 = np.vstack((arr1, arr2))
print(arr3)

# 横向合并
arr4 = np.hstack((arr1, arr2))
print(arr4)

# 合并两个矩阵
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[10, 20, 30], [40, 50, 60]])
# c = np.concatenate((a,b),axis=0)  默认情况 是 列合并，axis=0可以不写
c = np.concatenate((a, b), axis=1)  # 合并行
print(c)

矩阵分割

import numpy as np

p = np.arange(12).reshape(3, 4)
print(p)
print("---横向分割---")
print(np.vsplit(p, 3))
p1 = np.array_split(p, 3, axis=1)  # 其中 1 为 array的不等项目
print(p1)

print("---纵向分割---")
print(np.hsplit(p, 2))

广播

import numpy as np

Q = np.array([1, 2, 3])
Q5 = Q * 5
print(Q5)

R1 = np.array([[1], [10], [20]])
R2 = np.array([1,2,3])
R1_R2 = R1+R2
print(R1)
print(R2)
print(R1_R2)

图像处理

import numpy as np
from PIL import Image
im = Image.open('./photo/.jpg')
# im.show()

im = np.array(im)
print(im.shape)
print(im[1000,1000])
im_r = im[:,:,0]
Image.fromarray(im_r).show()

pandas

菜鸟教程：https://www.runoob.com/pandas/pandas-tutorial.html

series

import numpy as np
import pandas as pd

s1 = pd.Series([1, 2, 3, 4])
print(s1)
print(s1.values)
print(s1.index)

s2 = pd.Series(np.arange(10))
print(s2)

s3 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
print(s3)

DataFrame

DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。

DataFrame 构造方法如下：

pandas.DataFrame( data, index, columns, dtype, copy)

参数说明：

data：一组数据(ndarray、series, map, lists, dict 等类型)。
index：索引值，或者可以称为行标签。
columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。
dtype：数据类型。
copy：拷贝数据，默认为 False。

Pandas CSV 文件

CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。

CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。

Pandas 可以很方便的处理 CSV 文件

import pandas as pd

df = pd.read_csv('nba.csv')

print(df.to_string())

# to_string() 用于返回 DataFrame 类型的数据，如果不使用该函数，则输出结果为数据的前面 5 行和末尾 5 行，中间部分以 ... 代替。

import pandas as pd

df = pd.read_csv('nba.csv')

print(df)

print(df.head(10)) # 读取前面10行

print(df.tail(10))# 读取末尾10行

print(df.info()) #info() 方法返回表格的一些基本信息：

数据清洗

数据清洗是对一些没有用的数据进行处理的过程。

很多数据集存在数据缺失、数据格式错误、错误数据或重复数据的情况，如果要对使数据分析更加准确，就需要对这些没有用的数据进行处理。

在这个教程中，我们将利用 Pandas包来进行数据清洗。

如果我们要删除包含空字段的行，可以使用 dropna() 方法，语法格式如下：

DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

参数说明：

axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。
how：默认为 ‘any’ 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how=‘all’ 一行（或列）都是 NA 才去掉这整行。
thresh：设置需要多少非空值的数据才可以保留下来的。
subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。
inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。

我们可以通过 isnull() 判断各个单元格是否为空。

import pandas as pd

df = pd.read_csv('property-data.csv')

print (df['NUM_BEDROOMS'])
print (df['NUM_BEDROOMS'].isnull())

数据处理

# @Time    : 2021/11/11 10:25
# @Author  : XUN~MLF
# @File    : finally.py
# @Software: PyCharm


import openpyxl
import numpy as np
import pandas as pd
import xlwt
import collections

df1 = pd.read_csv('green_tripdata_2014-05.csv')
df2 = pd.read_csv('green_tripdata_2014-04.csv')

# 取出10行数据实验
data1 = df1.head(10)
data2 = df2.head(10)

# 取出指定行的数据
msg1 = pd.DataFrame(data1, columns=['Pickup_longitude',
                                    'Pickup_latitude',
                                    'Dropoff_longitude',
                                    'Dropoff_latitude',
                                    'Passenger_count',
                                    'Fare_amount'])
print(msg1)

msg2 = pd.DataFrame(data2, columns=['Pickup_longitude',
                                    'Pickup_latitude',
                                    'Dropoff_longitude',
                                    'Dropoff_latitude',
                                    'Passenger_count',
                                    'Fare_amount'])
print(msg2)

# 修该行的名字
massage1 = msg1.rename(columns={'Pickup_longitude': '上车经度',
                                'Pickup_latitude': '上车纬度',
                                'Dropoff_longitude': '下车经度',
                                'Dropoff_latitude': '下车纬度',
                                'Passenger_count': '乘客人数',
                                'Fare_amount': '费用'})
print(massage1)

massage2 = msg2.rename(columns={'Pickup_longitude': '上车经度',
                                'Pickup_latitude': '上车纬度',
                                'Dropoff_longitude': '下车经度',
                                'Dropoff_latitude': '下车纬度',
                                'Passenger_count': '乘客人数',
                                'Fare_amount': '费用'})
print(massage2)


# 2、删除为 0 的数据
def delete(data):
    for index, row in data.iteritems():
        data = data[data[index] != 0]
    print(data)
    return data


updateMassage1 = delete(massage1)
updateMassage2 = delete(massage2)


# 3、筛选数据
def getAllData(data):
    data = data[(data['上车经度'] > -73.89)
                & (data['上车纬度'] > 40.8)
                & (data['下车经度'] > -73.9)
                & (data['下车纬度']) < 40.8]
    print(data)
    return data


filtrateMassage1 = getAllData(updateMassage1)
filtrateMassage2 = getAllData(updateMassage2)

# 将数据合并
#  将数据写入新文件

filtrateMassage1.to_csv("2.csv", mode='a', index=False, header=True)
filtrateMassage2.to_csv("2.csv", mode='a', index=False, header=False)


# 写入excel中
# df = pd.read_csv('2.csv')
# # print(df)   #输出csv表格中结果
# data = collections.OrderedDict()   #有序字典
# # print(df.columns)     #列名
# for line in list(df.columns):
#     data[line] = list(df[line])    #构建excel格式
#
# obj = pd.DataFrame(data)
# obj.to_excel('test.xls',index=False)
# print('保存成功')

爬虫

爬取豆瓣电影top250海报并重命名

# @Time    : 2021/11/25 12:47
# @Author  : XUN~MLF
# @File    : text.py
# @Software: PyCharm
import requests
import re
from bs4 import BeautifulSoup


def getData():
    list_info = soup.find_all('ol', class_="grid_view")[0].find_all("li")
    for temp in list_info:
        # 获取评价人数
        findJudge = re.compile(r'<span>(\d*)人评价</span>')
        judgeNum = re.findall(findJudge, str(temp))[0]
        data_1.append(judgeNum)
        year_info = temp.find_all('div', class_='bd')
        for i in year_info:
            # 正则获取年份去除不需要的字符串只保留年份
            year = re.findall(r'\d+', i.find_all('p')[0].text)[0]
            year_data.append(year)
    print(data_1)
    print(year_data)


# 获取图片的数据
def getPictureUrl():
    picture_info = soup.find_all('div', class_="pic")
    for temp in picture_info:
        img_info = temp.find("img")
        movie_name = img_info.attrs["alt"]
        picture_url = img_info.attrs["src"]
        urlData.append(picture_url)
        nameData.append(movie_name)
        # print(movie_name, picture_url)


def main():
    getPictureUrl()
    getData()
    i = 0
    for temp in urlData:
        data = requests.get(temp)
        picture = data.content
        save_name = nameData[i] + '-' + year_data[i] + '-' + data_1[i]
        with open("E:/temp/" + f"{save_name}.jpg", "wb") as f:
            # 使用write()将图片写入
            f.write(picture)
        i = i + 1


if __name__ == "__main__":  # 当程序执行时
    for i in range(0, 10):
        page = i * 25
        url = 'https://movie.douban.com/top250?start=' + str(page)
        headers = {  # 模拟浏览器头部信息，向豆瓣服务器发送消息
            "User-Agent": "Mozilla / 5.0(Windows NT 10.0; Win64; x64) AppleWebKit / 537.36(KHTML, like Gecko) Chrome "
                          "/ 80.0.3987.122  Safari / 537.36 "
        }
        res = requests.get(url, headers=headers)
        html = res.text  # 服务器返回响应
        soup = BeautifulSoup(html, 'html.parser')

        urlData = []
        nameData = []
        year_data = []
        data_1 = []
        main()
    print("爬取图片完毕！")

爬取豆瓣点电影top250

# @Time    : 2021/11/18 11:03
# @Author  : XUN~MLF
# @File    : first.py
# @Software: PyCharm


import json
import re, requests
from lxml import etree
import pandas


# 获取网页的源码
def get_content(url, headers):
    response = requests.get(url, headers=headers)
    return response.text


# 获取电影指定信息
def get_movie_info(text):
    text = json.loads(text)
    item = {}
    for data in text:
        score = data['score']
        image = data['cover_url']
        title = data['title']
        actors = data['actors']
        detail_url = data['url']
        vote_count = data['vote_count']
        types = data['types']
        item['评分'] = score
        item['图片'] = image
        item['电影名'] = title
        item['演员'] = actors
        item['详情页链接'] = detail_url
        item['评价数'] = vote_count
        item['电影类别'] = types
        print(item)


# 获取电影api数据的
def get_movie(type, url):
    headers = {
        'X-Requested-With': 'XMLHttpRequest',
        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
    }
    n = 0
    # 获取api数据，并判断分页
    while True:
        text = get_content(url.format(type, n), headers=headers)
        if text == '[]':
            break
        get_movie_info(text)
        n += 20


# 主方法
def main():
    base_url = 'https://movie.douban.com/chart'
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
        'Referer': 'https://movie.douban.com/explore'
    }

    html_str = get_content(base_url, headers=headers)  # 分类页首页
    html = etree.HTML(html_str)
    movie_urls = html.xpath('//div[@class="types"]/span/a/@href')  # 获得每个分类的连接，但是切割type
    for url in movie_urls:
        p = re.compile('type=(.*?)&interval_id=')
        type_ = p.search(url).group(1)
        ajax_url = 'https://movie.douban.com/j/chart/top_list?type={}&interval_id=100%3A90&action=&start={}&limit=20'
        get_movie(type_, ajax_url)


if __name__ == '__main__':
    main()

爬取豆瓣电影top250并保存到excel中

# @Time    : 2021/11/18 9:55
# @Author  : XUN~MLF
# @File    : 豆瓣电影数据.py
# @Software: PyCharm
# -*- coding:UTF-8 -*-

from bs4 import BeautifulSoup  # 网页解析，获取数据
import xlwt  # 进行excel操作
import re  # 正则表达式，进行文字匹配
import urllib.request, urllib.error  # 制定URL，获取网页数据

# 影片详情链接
findLink = re.compile(r'<a href="(.*?)">')  # 创建正则表达式对象，标售规则   影片详情链接的规则
# 影片图片
findImgSrc = re.compile(r'<img.*src="(.*?)"', re.S)
# 影片名
findTitle = re.compile(r'<span class="title">(.*)</span>')
# 影片评分
findRating = re.compile(r'<span class="rating_num" property="v:average">(.*)</span>')
# 评价人数
findJudge = re.compile(r'<span>(\d*)人评价</span>')
# 概况
findInq = re.compile(r'<span class="inq">(.*)</span>')
# 影片相关内容
findBd = re.compile(r'<p class="">(.*?)</p>', re.S)


def main():
    baseurl = "https://movie.douban.com/top250?start="  # 要爬取的网页链接
    # 1.爬取网页
    datalist = getData(baseurl)
    savepath = "豆瓣电影Top250.xls"  # 当前目录新建XLS，存储进去
    # 3.保存数据
    saveData(datalist, savepath)  # 2种存储方式可以只选择一种


# 爬取网页
def getData(baseurl):
    dataset = []  # 用来存储爬取的网页信息
    for i in range(0, 10):  # 调用获取页面信息的函数，10次
        url = baseurl + str(i * 25)
        html = askURL(url)  # 保存获取到的网页源码
        # 2.逐一解析数据
        soup = BeautifulSoup(html, "html.parser")
        for item in soup.find_all('div', class_="item"):  # 查找符合要求的字符串
            data = []  # 保存一部电影所有信息
            item = str(item)
            link = re.findall(findLink, item)[0]  # 通过正则表达式查找
            data.append(link)
            imgSrc = re.findall(findImgSrc, item)[0]
            data.append(imgSrc)
            titles = re.findall(findTitle, item)
            if (len(titles) == 2):
                ctitle = titles[0]
                data.append(ctitle)
                otitle = titles[1].replace("/", "")  # 消除转义字符
                data.append(otitle)
            else:
                data.append(titles[0])
                data.append(' ')
            rating = re.findall(findRating, item)[0]
            data.append(rating)
            judgeNum = re.findall(findJudge, item)[0]
            data.append(judgeNum)
            inq = re.findall(findInq, item)
            if len(inq) != 0:
                inq = inq[0].replace("。", "")
                data.append(inq)
            else:
                data.append(" ")
            bd = re.findall(findBd, item)[0]
            bd = re.sub('<br(\s+)?/>(\s+)?', "", bd)
            bd = re.sub('/', "", bd)
            data.append(bd.strip())
            dataset.append(data)

    return dataset


# 得到指定一个URL的网页内容
def askURL(url):
    head = {  # 模拟浏览器头部信息，向豆瓣服务器发送消息
        "User-Agent": "Mozilla / 5.0(Windows NT 10.0; Win64; x64) AppleWebKit / 537.36(KHTML, like Gecko) Chrome / 80.0.3987.122  Safari / 537.36"
    }
    # 用户代理，表示告诉豆瓣服务器，我们是什么类型的机器、浏览器（本质上是告诉浏览器，我们可以接收什么水平的文件内容）

    request = urllib.request.Request(url, headers=head)
    html = ""
    try:
        response = urllib.request.urlopen(request)
        html = response.read().decode("utf-8")
    except urllib.error.URLError as e:
        if hasattr(e, "code"):
            print(e.code)
        if hasattr(e, "reason"):
            print(e.reason)
    return html


# 保存数据到表格
def saveData(dataset, savepath):
    print("save.......")
    book = xlwt.Workbook(encoding="utf-8", style_compression=0)  # 创建workbook对象
    sheet = book.add_sheet('豆瓣电影Top250', cell_overwrite_ok=True)  # 创建工作表
    col = ["电影详情链接", "图片链接", "影片中文名", "影片外国名", "评分", "评价数", "概况", "相关信息"]
    for i in range(0, 8):
        sheet.write(0, i, col[i])  # 列名
    for i in range(0, 250):
        # print("第%d条" %(i+1))       #输出语句，用来测试
        data = dataset[i]
        for j in range(0, 8):
            sheet.write(i + 1, j, data[j])  # 数据
    book.save(savepath)  # 保存


if __name__ == "__main__":  # 当程序执行时
    # 调用函数
    main()
    print("爬取完毕！")

爬取小说——斗破苍穹

# @Time    : 2021/9/8 11:59
# @Author  : XUN~MLF
# @File    : 03.爬斗破苍穹.py
# @Software: PyCharm

import requests
import sys
# -*- coding:UTF-8 -*-
from bs4 import BeautifulSoup


def get_contents(target):
    req = requests.get(url=target)
    html = req.text
    bf = BeautifulSoup(html, features="html.parser")
    texts = bf.find_all('div', class_='showtxt')
    texts = texts[0].text.replace('\xa0' * 8, '\n\n')
    return texts


def writer(name, path, text):
    write_flag = True
    with open(path, 'a', encoding='utf-8') as f:
        f.write(name + '\n')
        f.writelines(text)
        f.write('\n\n')


class downloader(object):

    def __init__(self):
        self.server = 'http://www.biqukan.com/' # 要爬的网址
        self.target = 'https://www.bqktxt.com/3_3037/' # 具体的网址
        self.names = []  # 存放章节名
        self.urls = []  # 存放章节链接
        self.nums = 0  # 章节数

    def get_download_url(self):
        req = requests.get(url=self.target)
        html = req.text
        div_bf = BeautifulSoup(html, features="html.parser")
        div = div_bf.find_all('div', class_='listmain')
        a_bf = BeautifulSoup(str(div[0]), features="html.parser")
        a = a_bf.find_all('a')
        self.nums = len(a[13:])  # 剔除不必要的章节，并统计章节数
        for each in a[13:]:
            self.names.append(each.string)
            self.urls.append(self.server + each.get('href'))


if __name__ == "__main__":
    dl = downloader()
    dl.get_download_url()
    print('《斗破苍穹》开始下载：')
    for i in range(dl.nums):
        writer(dl.names[i], '斗破苍穹.txt', get_contents(dl.urls[i]))
        sys.stdout.write("  已下载:%.3f%%" % float(i / dl.nums) + '\r')
        sys.stdout.flush()
    print('《斗破苍穹》下载完成')

爬取中国房价排行

# @Time    : 2021/11/23 13:40
# @Author  : XUN~MLF
# @File    : 中国房价数据获取.py
# @Software: PyCharm


import requests
from lxml import etree
import openpyxl


def main():
    # 1、要解析的网址
    url = "https://www.creprice.cn/rank/index.html"
    # 2、解析数据
    getData(url)


# 数据解析
def getData(url):
    # 新建workbook对象
    workbook = openpyxl.Workbook()
    # 创建正在操作的表
    sheet = workbook.active
    # 设置sheet表格的表头
    sheet.append(['序号', '城市名称', '平均单价', '环比', '同比'])

    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
                      "Chrome/96.0.4664.45 Safari/537.36 "
    }
    html = requests.get(url, headers=headers).text
    tree = etree.HTML(html)
    number = tree.xpath("//tbody[@class='ranklist']/tr/th[1]/text()")[1::]
    city_name = tree.xpath("//tbody[@class='ranklist']/tr/th[2]/a/text()")
    price = tree.xpath("//tbody[@class='ranklist']/tr/th[3]/text()")[1::]
    Hb = tree.xpath("//tbody[@class='ranklist']/tr/th[4]/text()")[1::]
    Tb = tree.xpath("//tbody[@class='ranklist']/tr/th[5]/text()")[1::]
    for i in range(0, len(city_name)):
        data = [number[i], city_name[i], price[i], Hb[i], Tb[i]]
        print(data)
        sheet.append(data)
    workbook.save('中国房价排行.xls')


if __name__ == "__main__":  # 当程序执行时
    # 调用函数
    main()
    print("爬取完毕！")

爬取宿舍电量并发邮件

# 导入模块
import json
import pymysql
import time
import requests
import datetime
import smtplib
from email.mime.text import MIMEText
from email.header import Header


# 获取json串
def do_getJson():
    session_request = requests.session()
    login_url = 'http://www.jxusptpay.com/StudentApp/Login/Login/Login'  # 登录时请求的url
    result = session_request.post(
        login_url,
        data={  # 构造post请求的数据,按顺序复制粘贴参数就好了

            # 校园通账户
            'studentCode': '账号',
            'password': '密码'
        },
        headers=dict(referer=login_url)
    )

    print(result.content.decode('utf-8'))  # 可以输出一下返回结果：）

    # 首页
    url = "http://www.jxusptpay.com/StudentApp/Home/Home/GetDormitoryElectricity"
    res = session_request.get(
        url,
        headers=dict(referer=url)
    )
    print(res.content.decode('utf-8'))  # 可以输出一下返回结果：）
    json_obj = json.loads(res.content.decode('utf-8'))
    print(json_obj)
    # 获取剩余电量
    electric = json_obj.get("data").get("electric")
    return electric


def sendEmail():
    electric = do_getJson()
    # 将读取的数据写入一个文件
    now_time = datetime.datetime.now()
    # 获取昨天
    last_time = (now_time + datetime.timedelta(days=-1)).strftime("%Y-%m-%d")
    print(last_time)
    fileName = time.strftime("%Y-%m-%d", time.localtime()) + '.txt'
    file = open(fileName, 'w')
    file.write(electric)
    file.close()

    file = open(fileName, 'r')
    print(file.readlines())
    # 发送邮件
    account = "2407942305@qq.com"
    password = "wmknzzcusfhudhij"
    qqNumberList = ["2060732584@qq.com"]
    mailhost = 'smtp.qq.com'
    qqmail = smtplib.SMTP()
    qqmail.connect(mailhost, 25)
    qqmail.login(account, password)
    content = "今日D1-517剩余电量" + electric + "\n"
    message = MIMEText(content, 'plain', 'utf-8')
    subject = '今日D1-517剩余电量'
    message['Subject'] = Header(subject, 'utf-8')
    try:
        for i in qqNumberList:
            qqmail.sendmail(account, i, message.as_string())
        else:
            print('邮件发送成功')
    except:
        print('邮件发送失败')
    qqmail.quit()


sendEmail()

爬取京东评论并保存到excel中

import openpyxl
import requests

# 新建workbook对象
workbook = openpyxl.Workbook()
# 创建正在操作的表
sheet = workbook.active
# 设置sheet表格的表头
sheet.append(['id', 'comments'])
for page in range(0,10):
    url = "https://club.jd.com/comment/productPageComments.action?callback=&productId=10023632209832&score=0&sortType=5&page=" + str(page) + "&pageSize=10&isShadowSku=0&fold=1"
    headers = {
        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 11) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'
    }

    response = requests.get(url, headers=headers)

    # 将json转换为字典
    js_data = response.json()

    # 获取评论所在地方
    content_list = js_data['comments']

    # 提取需要的ID及评论
    for content in content_list:
        data = []
        id = content.get('id')
        data.append(id)
        content = content.get('content')
        data.append(content)
        sheet.append(data)
        print(id)
        print(content)
workbook.save('京东评论.xls')

数据可视化（pyecharts）

柱状图

from pyecharts.charts import Bar
from pyecharts.globals import ThemeType
import pandas as pd


df = pd.read_excel("中国房价排行.xls")  # 读取excel的文件
city_name = list(df['城市名称'].head(20))
price = list(df['平均单价'].head(20))
print(city_name)
print(price)

c = (
    Bar({"theme": ThemeType.MACARONS})
    .add_xaxis(city_name)
    .add_yaxis("房价", price)
    .set_global_opts(
        title_opts={"text": "中国房价top20"}
    )
    .render("house_price_top20.html")
)

饼状图

import pyecharts.options as opts
from pyecharts.charts import Pie
import pandas as pd


x_data = ["房价0~5k元/每平方", "房价5k~1w元/每平方", "房价1w~2w元/每平方", "房价2w~4w元/每平方", "4w元/每平方以上"]
data = pd.read_excel("中国房价排行.xls")

msg1 = data[['平均单价']][0:74:1]

# 1W~2W的城市个数
city_1w_2w = msg1[msg1['平均单价'] < '2']
sum_1w_2w = len(city_1w_2w)
print(sum_1w_2w)
# print(city_1w_2w)

# 2w~4W的城市个数
city_2w_4w = msg1[msg1['平均单价'] < '4']
sum_2w_4w = len(city_2w_4w) - sum_1w_2w
print(sum_2w_4w)
# print(city_2w_4w)

# 4W以上的城市个数
sum_4w_n = len(msg1) - sum_2w_4w - sum_1w_2w
print(sum_4w_n)
# print(city_2w_4w)


msg2 = data[['平均单价']][75::1]

# 0~5k城市个数
city_0k_5k = msg2[msg2['平均单价'] < '5']
sum_0k_5k = len(city_0k_5k)
# 5K~1w城市个数
sum_5k_1w = len(msg2) - sum_0k_5k
print(sum_0k_5k)
print(sum_5k_1w)

y_data = [sum_0k_5k, sum_5k_1w, sum_1w_2w, sum_2w_4w, sum_4w_n]

(
    Pie(init_opts=opts.InitOpts(width="1400px", height="800px"))
    .add(
        series_name="房价占比",
        data_pair=[list(z) for z in zip(x_data, y_data)],
        radius=["50%", "70%"],
        label_opts=opts.LabelOpts(is_show=False, position="center"),
    )
    .set_global_opts(legend_opts=opts.LegendOpts(pos_left="legft", orient="vertical"))
    .set_series_opts(
        tooltip_opts=opts.TooltipOpts(
            trigger="item", formatter="{a} <br/>{b}: {c} ({d}%)"
        ),
        # label_opts=opts.LabelOpts(formatter="{b}: {c}")
    )
    .render("house_price.html")
)

件发送失败’)
qqmail.quit()

sendEmail()






## 爬取京东评论并保存到excel中

```python
import openpyxl
import requests

# 新建workbook对象
workbook = openpyxl.Workbook()
# 创建正在操作的表
sheet = workbook.active
# 设置sheet表格的表头
sheet.append(['id', 'comments'])
for page in range(0,10):
    url = "https://club.jd.com/comment/productPageComments.action?callback=&productId=10023632209832&score=0&sortType=5&page=" + str(page) + "&pageSize=10&isShadowSku=0&fold=1"
    headers = {
        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 11) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'
    }

    response = requests.get(url, headers=headers)

    # 将json转换为字典
    js_data = response.json()

    # 获取评论所在地方
    content_list = js_data['comments']

    # 提取需要的ID及评论
    for content in content_list:
        data = []
        id = content.get('id')
        data.append(id)
        content = content.get('content')
        data.append(content)
        sheet.append(data)
        print(id)
        print(content)
workbook.save('京东评论.xls')

数据可视化（pyecharts）

柱状图

from pyecharts.charts import Bar
from pyecharts.globals import ThemeType
import pandas as pd


df = pd.read_excel("中国房价排行.xls")  # 读取excel的文件
city_name = list(df['城市名称'].head(20))
price = list(df['平均单价'].head(20))
print(city_name)
print(price)

c = (
    Bar({"theme": ThemeType.MACARONS})
    .add_xaxis(city_name)
    .add_yaxis("房价", price)
    .set_global_opts(
        title_opts={"text": "中国房价top20"}
    )
    .render("house_price_top20.html")
)

饼状图

import pyecharts.options as opts
from pyecharts.charts import Pie
import pandas as pd


x_data = ["房价0~5k元/每平方", "房价5k~1w元/每平方", "房价1w~2w元/每平方", "房价2w~4w元/每平方", "4w元/每平方以上"]
data = pd.read_excel("中国房价排行.xls")

msg1 = data[['平均单价']][0:74:1]

# 1W~2W的城市个数
city_1w_2w = msg1[msg1['平均单价'] < '2']
sum_1w_2w = len(city_1w_2w)
print(sum_1w_2w)
# print(city_1w_2w)

# 2w~4W的城市个数
city_2w_4w = msg1[msg1['平均单价'] < '4']
sum_2w_4w = len(city_2w_4w) - sum_1w_2w
print(sum_2w_4w)
# print(city_2w_4w)

# 4W以上的城市个数
sum_4w_n = len(msg1) - sum_2w_4w - sum_1w_2w
print(sum_4w_n)
# print(city_2w_4w)


msg2 = data[['平均单价']][75::1]

# 0~5k城市个数
city_0k_5k = msg2[msg2['平均单价'] < '5']
sum_0k_5k = len(city_0k_5k)
# 5K~1w城市个数
sum_5k_1w = len(msg2) - sum_0k_5k
print(sum_0k_5k)
print(sum_5k_1w)

y_data = [sum_0k_5k, sum_5k_1w, sum_1w_2w, sum_2w_4w, sum_4w_n]

(
    Pie(init_opts=opts.InitOpts(width="1400px", height="800px"))
    .add(
        series_name="房价占比",
        data_pair=[list(z) for z in zip(x_data, y_data)],
        radius=["50%", "70%"],
        label_opts=opts.LabelOpts(is_show=False, position="center"),
    )
    .set_global_opts(legend_opts=opts.LegendOpts(pos_left="legft", orient="vertical"))
    .set_series_opts(
        tooltip_opts=opts.TooltipOpts(
            trigger="item", formatter="{a} <br/>{b}: {c} ({d}%)"
        ),
        # label_opts=opts.LabelOpts(formatter="{b}: {c}")
    )
    .render("house_price.html")
)

XUN~MLF 2021/12/09

XUN~MLF

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python

简介python简介Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。Python 是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。Python 是交互式语言：这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。Python 是面向对象语言: 这意味着Pytho
复制链接

扫一扫