关于这学期的总结
Posted hany-postq473111315
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了关于这学期的总结相关的知识，希望对你有一定的参考价值。
# 例1-2 正确缩进
# 比较两个数字对于π的精度，保持缩进一致
pie = 3.1415
pie1 = 3.14
# 同一代码块内各行缩进空格数目相同，观察输出结果
if pie > pie1:
print(‘π取pie更精确‘)
elif pie == pie1:
print(‘π取pie或pie1一样精确‘)
else:
print(‘π取pie1更精确‘)
# 例1-4 长语句换行
# 给出3种水果的价格，计算总价
apple_price, banana_price, pear_price = 1, 1.5, 0.5
# 通过反斜杠实现长语句换行
total_price = apple_price + banana_price + pear_price
print(‘total_price =‘, total_price)
# 例1-5 逗号换行
# 方括号内，在逗号后直接换行
total_price = sum([apple_price,
banana_price,
pear_price])
print(‘total_price =‘, total_price)
# 例1-6 分号隔离
# 给出3种水果的价格，计算总价
apple_price = 1; banana_price = 1.5; pear_price = 0.5
total_price = apple_price + banana_price + pear_price
print(‘total_price =‘, total_price)
import keyword
print(‘Python中的所有保留字为：
‘,keyword.kwlist)
# 例1-8 赋值的基本形式
# 使用等号直接给num_int赋值一个整数值
num_int = 1
print(‘使用等号创建的整数为：‘, num_int)
# 使用等号直接给num_float赋值一个浮点数值
num_float = 9.9
print(‘使用等号创建的浮点数为：‘, num_float)
# 使用等号直接给string赋值一个字符串
string = ‘python‘
print(‘使用等号创建的字符串为：‘, string)
# 例1-9 序列赋值
# 序列赋值可给变量赋值多种数据类型
num_int, string, list1 = 123, ‘str‘, [4,6]
print(‘赋值创建的多种数据类型为：‘, num_int, string, list1)
# 序列赋值可给变量赋值已赋值的变量
num1, num2, num3 = 7, 8, 9
num_int1, num_int2, num_int3 = num1, num2, num3
print(‘变量赋值为已赋值变量结果为：‘, num_int1, num_int2, num_int3)
# 例1-10 链接赋值
str1 = str2 = str3 = ‘STR‘
print(‘str1, str2, str3分别为：‘, str1, str2, str3)
print(‘str1, str2, str3的内存地址分别为：‘, id(str1), id(str2), id(str3))
print(‘str1, str2, str3是否等价：‘, str1 is str2 is str)
# 代码1-11 增量赋值
x = 100
x += 10
print(‘x += 10等价于x=x+10，其值为：‘, x)
# 例1-12 算术运算
num_int = 4
num_float = 4.0
print(‘整数与浮点数的和为：‘, num_int + num_float)
print(‘整数与浮点数的差为：‘, num_int - num_float)
print(‘整数与浮点数的积为：‘, num_int * num_float)
print(‘浮点数与整数的商为：‘, num_float / num_int)
print(‘浮点数对整数取模结果为：‘, num_float % num_int)
print(‘浮点数的整数次幂为：‘, num_float ** num_int)
# 例1-13 赋值运算
num_int1 = 4
print(‘赋值后num_int1为：‘, num_int1)
num_int1 = 4 + 6
print(‘赋值后num_int1为：‘, num_int1)
num_int1 = 4 * 2
print(‘赋值后num_int1为：‘, num_int1)
num_int1 = 4 / 2
print(‘赋值后num_int1为：‘, num_int1)
num_int1 = 4 % 2
print(‘赋值后num_int1为：‘, num_int1)
num_int1 = 4 ** 2
print(‘赋值后num_int1为：‘, num_int1)
# 例1-14 比较运算
num_int = 4
num_float = 4.0
print(‘num_int与num_float是否相等：‘, num_int == num_float)
print(‘num_int与num_float是否不相等：‘, num_int != num_float)
print(‘num_int是否大于num_float：‘, num_int > num_float)
print(‘num_int是否小于num_float：‘, num_int < num_float)
print(‘num_int是否大于等于numfloat：‘, num_int >= num_float)
print(‘num_int是否小于等于num_float：‘, num_int <= num_float)
# 例1-15 逻辑运算
num_bool1 = False
num_bool2 = True
print(‘num_bool1 and num_bool2返回值为：‘, num_bool1 and num_bool2)
print(‘num_bool1 or num_bool2返回值为：‘, num_bool1 or num_bool2)
print(‘not num_bool2的返回值为：‘, not (num_bool2))
# 例1-16 身份运算
num_int1 = 15
num_int3 = 15
print(‘num_int1与num_int3储存单位是否相同：‘, num_int1 is num_int3)
num_int2 = 15.0
print(‘num_int1与num_int2储存单位是否相同：‘, num_int1 is num_int2)
# 如果储存单位相同就返回True，否则返回False
print(‘num_int1与num_int3储存单位是否不同：‘, num_int1 is not num_int3)
print(‘num_int1与num_int2储存单位是否不同：‘, num_int1 is not num_int2)
# 例1-17 成员运算
num_int1 = 15
list2 = [1, ‘apple‘, 15]
print(‘num_int1是否在list2中：‘, num_int1 in list2)
array = (‘orange‘, 6, 15)
print(‘num_int1是否不在array中：‘, num_int1 not in array)
# 例1-18 运算符优先级
# 先执行乘除法运算，再执行加减法运算
print(‘num_float + num_int1 / num_int3 =‘, num_float + num_int1 / num_int3)
# 先执行加减法运算，再执行比较运算
print(‘num_int1 - num_int2 > num_int1 - num_int3：‘,
num_int1 - num_int2 > num_int1 - num_int3)
# 先执行加减法运算，再做身份判断
print(‘num_int1 - num_int3 + num_int1 is num_int1：‘,
num_int1 - num_int3 + num_int1 is num_int1)
# 先执行指数运算，再执行减法运算，最后做身份判断
print(‘num_float ** 2 - 1 is not num_int2：‘,
num_float ** 2 - 1 is not num_int2)
#例1-19 创建 number
num_int = 2
num_float = 4.5
num_bool = True
num_complex = 3j
print(‘数据类型分别为：
‘, type(num_int),
type(num_float), type(num_bool), type(num_complex))
# 例1-20 number 类型装换与混合运算
# number类型转换， 将float转换为int（直接去掉小数部分）
print(‘int(4.5)的结果为：‘, int(4.5))
# 将int转换为float（直接增加小数部分）
print(‘float(4)的结果为：‘, float(4))
# 将int和float转换为complex（直接增加虚部）
print(‘complex(4)和complex(4.5)的结果分别为：‘, complex(4), complex(4.5))
# 不同number类型混合运算， int + float = float
print(‘整数和浮点数和的类型为：‘, type(124 + 4.0))
# int + complex = complex
print(‘整数和复数和的类型为：‘, type(124 + 5.3j))
# float + complex = complex
print(‘浮点数和复数和的类型为：‘, type(4.0 + 5.3j))
# 例1-21 str 索引
string = "ilovePython"
# 下标为正数，从第2个字符开始索引，到第5个字符
print(‘ilovePython[1:5] =‘, string[1:5])
# 下标为负数，从倒数第10个字符开始索引，到倒数第6个字符
print(‘ilovePython[-10:-6] =‘, string[-10:-6])
print(‘ilovePython[:5] =‘, string[:5])
# 尾下标留空，从第2个字符开始索引，到最后一个字符截止
print(‘ilovePython[1:] =‘, string[1:])
# 按步索引，从第2个元素开始索引，到第11个元素，步距为3
print(‘ilovePython[1:10:3] =‘, string[1:10:3])
# 例1-22 str 查询方法
print(‘string中n的位置和总数分别为：‘, string.index(‘n‘), string.count(‘n‘))
print(‘string中是否只包含字母：‘, string.isalpha())
print(‘string中是否只包含数字：‘, string.isdigit())
print(‘string是否已P开头：‘, string.startswith(‘P‘))
print(‘string是否是标题化的：‘, string.istitle())
# 例1-23 str 改写方法
print(‘string左对齐填充至20个字符结果为：‘, string.ljust(20))
print(‘string右对齐填充至20个字符结果为：‘, string.rjust(20))
print(‘string大写化结果为：‘, string.upper())
print(‘string大小写置换结果为：‘, string.swapcase())
print(‘string中h替换为H结果为：‘, string.replace(‘h‘,‘H‘))
# 例1-24 str 方法-其他
# 以指定格式编码
string = string.encode(‘UTF-16‘, ‘strict‘)
print ("string编码为：", string)
# 以指定格式解码
string = string.decode(‘UTF-16‘, ‘strict‘)
print ("string解码为：", string)
# 以指定分隔符分割str
print(string.partition("."))
string1 = (‘I‘,‘love‘,‘Python‘)
sep = ‘-‘
# 以sep为分隔将string1合并为新的字符串
print(‘以sep分隔合并string1为：‘, sep.join(string1))
# 例1-25 str 转义与常用操作
print (‘
otemybook‘) # str中包含
，识别为换行符并转义
print (‘ itlemybook‘) # str中包含 ，识别为制表符并转义
print (r‘
otemybook ‘) # 使用r制止转义
print (string + "TEST") # 输出连接的str
print (string * 2) # 输出str两次
# 例1-26 创建 list
# 使用方括号创建一个非空list
list1 = [‘runoob‘, 786, 2.23, ‘john‘]
print(‘方括号建立的列表为：‘, list1)
#建立元组
tuple1 = (123, ‘xyz‘, ‘zara‘, ‘abc‘)
list2 = list(tuple1)
print(‘元组转换成列表结果为：‘, list2)
# list函数将str拆开，作为新list中的元素
list3 = list(‘china‘)
print(‘字符串转换成列表结果为：‘, list3)
# 例1-27 list 基本操作
print(‘列表按指定长度索引结果为：‘, list3[-4:-2])
print(‘列表按步长索引结果为：‘, list3[0::2])
list1[2] = 666
print(‘列表替换结果为：‘, list1)
print(‘list1和list2用+连接结果为：‘, list1 + list2)
print(‘列表通过*重复结果为：‘, list1 * 2)
# 例1-28 list 常用方法
print(‘list3中a出现的次数：‘, list3.count(‘a‘), ‘
‘, ‘list3中a首次出现的位置：‘, list3.index(‘a‘))
list3.insert(0,‘g‘)
list1.append(‘新增‘)
list2.extend(list3)
print(‘在列表指定位置插入元素：‘, list3, ‘
‘, ‘在列表末尾新增元素：‘, list1, ‘
‘, ‘将list3扩展至list2：‘, list2)
list3.insert(0,‘g‘)
list1.append(‘新增‘)
list2.extend(list3)
print(‘在列表指定位置插入元素：‘, list3, ‘
‘, ‘在列表末尾新增元素：‘, list1, ‘
‘, ‘将list3扩展至list2：‘, list2)
list3.pop(0)
list1.remove(‘新增‘)
print(‘使用pop删除指定位置的元素：‘, list3, ‘
‘, ‘使用remove删除指定元素：‘, list1)
list2.pop(0)
list2.sort()
list3.reverse()
print(‘列表排序：‘, list2, ‘
‘, ‘列表反向排序：‘, list3)
# 例1-29 创建tuple
# 使用圆括号创建tuple
tup1 = (‘Google‘, ‘Runoob‘)
print(‘查看tup1类型：‘, type(tup1), ‘
‘, ‘查看tup1：‘, tup1)
# 不加括号创建tuple
tup2 = "a", "b", "c", "d"
print(‘查看tup2：‘, tup2, ‘
‘, ‘查看tup2类型：‘, type(tup2))
# 将[‘x‘,’y‘,’z‘]转换成tuple
tup3 = tuple([‘x‘,‘y‘,‘z‘])
print(‘查看tup3：‘, tup3, ‘
‘, ‘查看tup3类型：‘, type(tup3))
# 单个数字元素加逗号，变量是tuple
tup4 = (50,)
# 单个数字元素无逗号，变量是int
tup5 = (50)
print(‘tup4和tup5的类型分别为：‘, type(tup4), type(tup5))
# 例1-30 tuple 基本操作
print(‘tup2中第3元素为：‘, tup2[2])
print(‘tup2中第1个到倒数第二个元素为：‘, tup2[:-1])
print(‘连接两个元组结果为：‘, tup1 + tup2)
print(‘元组重复输出结果为：‘, tup3 * 2)
# 例1-31 tuple 内置方法
print(‘tup2中元素a出现的次数：‘, tup2.count(‘a‘))
print(‘tup2中元素a首次出现的位置：‘, tup2.index(‘a‘))
# 例1-32 创建 dict
# 使用花括号创建空dict，更新键值对
dict1 = {}
dict1[‘one‘] = "This is 1"
dict1[‘two‘] = "This is 2"
print(‘查看字典：‘, dict1)
# 使用dict函数创建dict，指定键值对
dict2 = dict(name=‘小明‘, height=187)
print(‘查看字典：‘, dict2)
# 例1-33
print(‘通过键索引字典元素：‘, dict1[‘one‘])
dict1[‘one‘] = ‘this is 1‘
print(‘以键改字典元素值：‘, dict1)
dict1[3] = ‘This is 3‘
print(‘更新后的字典为：‘, dict1)
del dict1[3]
print(‘删除键3后的字典为：‘, dict1)
# 例1-34 dict 内置方法
print(‘输出dict1中所有键值对：‘, dict1.items(), ‘
‘,
‘输出dict1中所有的键：‘, dict1.keys(), ‘
‘,
‘输出dict1中所有的值：‘, dict1.values())
print(‘与one对应的元素为：‘, dict1.get(‘one‘), dict1.setdefault(‘one‘))
dict1.update(dict2)
dict3 = dict2.copy()
print(‘将dict2中键值对更新到dict1中：‘, dict1, ‘
‘,
‘将dict2中内容复制到新的字典中：‘, dict3)
dict1.pop(‘name‘)
dict2.popitem()
dict3.clear()
print(‘删除dict1中name键对应的内容：‘, dict1, ‘
‘,
‘随机删除dict2中的一个键值对为：‘, dict2.popitem(), ‘
‘,
‘清空dict3中的内容：‘, dict3)
# 例1-35 创建 set
# 使用非空的{}创建set
set1 = {1, 2, 3}
print(‘set1的类型为：‘, type(set1))
# 创建一个空的set只能使用set函数
set2 = set()
print(‘查看set2：‘, set2, ‘
‘, ‘set2的类型为：‘, type(set2))
# 将list、tuple转换为set
set3 = set([1,2,3])
set4 = set((1,2,3))
print(‘查看set3和set4：‘, set3, set4, ‘
‘,
‘set3和set4的类型分别为：‘, type(set3), type(set4))
# 例1-36 set 常用方法
set1.add(‘a‘)
print(‘add方法向set1中添加元素结果为：‘, set1)
set1.pop()
print(‘pop方法删除set1中任意一个元素结果为：‘, set1)
set2.clear()
print(‘清除set2中内容结果为：‘, set2)
# 例1-37 set 集合运算
print(‘set4是否为set1的子集：‘, set4 < set1)
print(‘set4和set1的并集为：‘, set4 | set1)
print(‘set4和set1的交集为：‘, set4 & set1)
print(‘set4和set1的差集为：‘, set4 - set1)
# # 例1-38 输入不同数据类型
# # 输入一个数字，由Python默认类型
# number1 = input(‘请输入一个数字：‘)
# # 输入一个str，由Python默认类型
# str1 = input(‘请输入一个字符串：‘)
# # 输入一个数字，并将其转换为int类型
# number2 = int(input(‘请输入一个数字：‘))
# # 查看以上输入的输出结果类型
# print(‘number1、str1和number2的类型分别为：
‘,
# type(number1), type(str1), type(number2))
# 例1-39 print 函数应用
# print函数接受多个str
print(‘我‘, ‘爱‘, ‘中华‘)
# print函数在打印前计算结果
print(‘100+200 =‘, 100 + 200)
# 例1-40 “ % + 格式符” 格式化输出
# 用%s、%d分别格式化字符串‘Zara‘和整数20
print("我的名字叫做%s，已经%d岁了！"%(‘Zara‘,20))
# 用%d格式化16，用%o将十进制整数16用八进制数表示
print("%d 的八进制是 %o"%(16,16))
# 用%.3f将整数转化为保留小数点后3位的float
print("23 转化为保留3位小数的浮点数%.3f"%(23))
# format函数不带参数情况下的输出
print("我的名字叫做{}，已经{}岁了！".format(‘Zara‘, 18))
# format函数带数字编号并打乱顺序
print("我的名字叫做{1}，已经{0}岁了！".format(18, ‘Zara‘))
# format函数带关键字参数
print("我的名字叫做{name}，已经{age}岁了！".format(age=18,name=‘Zara‘))
# format函数格式化数字为二进制数
print("我的名字叫做{}，已经{:b}岁了！".format(‘Zara‘, 18))
# # 例1-41 read 函数读取 test.txt 文件
# # 以只读模式打开test.txt文件
# data = open(‘../data/test.txt‘, ‘r‘)
# # 读取文件中的内容，存到content变量中
# content = data.read()
# # 打印出content变量中包含的文本内容
# print(‘该文本中的内容是：‘, content)
# #例1-42 write 函数写入文件
# # 打开一个文件
# web = open(‘../data/web.txt‘, ‘w‘)
# # 转换内容，写入文件
# value = (‘http://www.tipdm.org‘, 14)
# str_value = str(value)
# web.write(str_value)
# web.close()
# # 打开文本，读取出写入的内容
# web = open(‘../data/web.txt‘, ‘r‘)
# content = web.read()
# print(‘该文本中的内容是：‘, content)
# # 例1-43 if-else语句实现登录界面
# name = input (‘请输入用户名：‘)
# password = input (‘请输入密码：‘)
# if name == "Lucy" and password == "123456":
# print (‘****登录成功，欢迎！*****‘)
# else:
# print (‘-----您的输入有误，登录失败！-----‘)
# # 例1-44 使用if-elif-else语句实现年龄段的判断
# age = input(‘请输入您的年龄：‘)
# age = int(age)
# if age < 18:
# print(‘未成年人！‘)
# elif age >= 18 and age <= 25:
# print(‘青年人！‘)
# elif age > 25 and age <= 60:
# print(‘中年人！‘)
# else:
# print(‘老年人！‘)
# #例1-45 嵌套if-elif-else语句
# age = input(‘请输入你的年龄：‘)
# age = int(age)
# if age == 35:
# nation = input(‘请输入你的国籍：‘)
# if nation == ‘英国‘:
# print(‘你是Tom! ‘)
# elif (nation == ‘法国‘):
# print(‘你是Frank! ‘)
# else:
# print(‘你是Bob! ‘)
# elif age == 21:
# print(‘你是Jane，来自南非! ‘)
# elif age == 51:
# print(‘你是Washington，来自澳大利亚! ‘)
# else:
# print(‘请输入正确年龄值! ‘)
# 例1-46 if-else语句的单行形式
num1, num2 = 11, 90
print(‘num1加num2为百分数‘) if 1000 > num1 + num2 >100 else print(‘num1加num2不为百分数‘)
# 例1-47 for语句遍历提取str
# 单纯遍历的for语句
names = [‘Michael‘, ‘Bob‘, ‘Tracy‘]
# 遍历输出names中的元素
for name in names:
print(name)
#例1-48 for语句遍历查询dict
dic = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4}
# 遍历键值对
print(‘
key_value：‘, end = ‘‘)
for key, value in dic.items():
print(key, value, sep = ‘:‘, end = ‘ ‘)
# 遍历键
print(‘
keys：‘, end = ‘‘)
for key in dic.keys():
print(key, end = ‘ ‘)
# 遍历值
print(‘
values：‘, end = ‘‘)
for value in dic.values():
print(value, end = ‘ ‘)
# # 例1-49 嵌套for语句
# students = [‘小明‘, ‘小红‘]
# subjects = [‘语文‘, ‘数学‘]
# sum1 = []
# avg = []
# for i in students:
# print (‘开始录入%s的考试成绩!‘%i)
# sum = 0
# for j in subjects:
# print(‘请输入%s成绩:‘%j)
# score = int(input())
# sum += score
# average = sum / 2
# avg.append(average)
# sum1.append(sum)
# print(students, ‘的总分依次是‘, sum1, ‘,‘, ‘平均分依次是‘, avg)
# print(‘完成成绩录入！‘)
# 例1-50 while语句
sum = 0
n = 99
while n > 0:
sum += n
n -= 2
print(sum)
# # 例1-51 嵌套while语句
# j = 1
# while j <= 2:
# sum = 0
# i = 1
# name = input(‘请输入学生姓名:‘)
# while i <= 2:
# print (‘请输入第%d门的考试成绩: ‘%i)
# sum += int(input())
# i += 1
# avg = sum / (i-1)
# print(name, ‘的平均成绩是%d‘%avg)
# j += 1
# print(‘学生成绩输入完成！‘)
# 例1-52 break语句的使用
# break语句用于for循环
string = "Python"
for i in string:
# 遍历至string中的字符n时，不再执行else代码块
if i == ‘n‘:
break
else:
print("letter：{}". format(i))
# break语句用于while循环
counts = 0
while True:
print(counts)
counts += 1
# 满足counts等于3时跳出循环，不再进入循环体
if counts == 3:
break
# 例1-53
# 第一层循环，遍历次数为2
for i in range(2):
print("-----%d-----" %i)
# 第二层循环，遍历次数为5
for j in range(5):
# 当j等于2或4时，不执行循环体
if j == 2 or j == 4:
continue
print(j)
# 例1-54
for element in "Python":
# element为y时，不做任何操作，不会被输出
if element == "y":
pass
else:
print(element)
counts = 0
while counts < 5:
counts += 1
# i=3时，不执行循环体
if counts == 3:
pass
else:
print(counts ** 2)
# 例1-55
vec = [-4, -2, 0, 2, 4]
# 用vec中元素的倍数，创建一个数组
print([x * 2 for x in vec])
# 创建一个包含2元tuple的list
print([(x, x ** 2) for x in range(6)])
# 例1-56
list1 = [1, 2, 3, 4]
# bytes函数、bytearray函数
print(‘list1的不可变字节数组为：‘, bytes(list1), ‘
‘,
‘list1的可变字节数组为：‘, bytearray(list1))
# chr函数、ord函数
print(‘整数40的unicode字符为：‘, chr(40), ‘
‘,
‘unicode字符(对应的整数为：‘, ord(‘(‘))
# bin函数
print(‘整数40的二进制形式为：‘, bin(40))
# ascii函数
print(‘字符串tipdm的ascii码为：‘, ascii(‘tipdm‘))
# hash函数
print(‘字符串tipdm的hash值为：‘, hash(‘tipdm‘))
# 例 1-57
# max函数、min函数
print(‘序列中的最大数为：‘, max(list1), ‘
‘,
‘序列中的最小数为：‘, min(list1))
# abs函数
print(‘-10和100的绝对值分别为：‘, abs(-10), abs(100))
# pow函数
print(‘3的6次方为：‘, pow(3, 6))
# round函数
print(‘3.2四舍五入结果为：‘, round(3.2))
# divmod函数
print(‘7除以3的商和余数分别为：‘, divmod(7, 3))
#例 1-58
# map函数
# 对一个list中的各个float分别四舍五入
print(‘浮点数的四舍五入结果为：‘, list(map(round, [1.1, 2.2, 3.3, 4.4, 5.5])))
# zip函数
list3 = [1, 2, 3]
list4 = [4, 5, 6]
zipped = zip(list3, list4)
# zip函数直接返回的是数据对象
print(‘返回对象为：‘, zipped, ‘
‘, ‘返回为list：‘, list(zipped))
# 例1-59
def exponent(a, b):
x = a ** b
return x
print(‘自定义幂运算的返回值为：‘, exponent(3, 6))
# 例 1-60
# 无参数，无返回值
def hello():
print(‘Hello!‘)
hello()
print(‘***以上为hello()的输出，以下为print(hello())的输出***‘)
print(hello())
# 无参数，有返回值
def func():
return("Python")
func()
# 多参数，无返回值
def func1(a, b):
print("a + b = %d"%(a + b))
func1(3, 4)
# 多参数，有返回值
def func2(a, b):
return (a + b)
print(‘a、b加和为：‘, func2(4, 3))
# 多个返回值
def maxtomin(a, b):
#返回a,b从大到小的排列
if a > b:
return a, b
else:
return b, a
print(‘a、b排序为：‘, maxtomin(2, 4))
# 例 1-61
# 使用位置参数
def func3(b, a, c):
return (a ** 2, b ** 2, c ** 2)
result = func3(1, 2, 3)
print(‘1、2、3经函数func3运算的结果为：‘, result)
# 使用关键字参数
def func4(a, b, c):
return (a ** 2, b ** 2, c ** 2)
result1 = func4(b=2, a=1, c=3)
print(‘1、2、3经函数func4运算的结果为：‘, result1)
# 混合使用位置参数和关键字参数，位置参数必须在关键字参数的前面
def func5(a, b, c):
return (a ** 2, b ** 2, c ** 2)
result2 = func5(1, c=3, b=2)
print(‘1、2、3经函数func5运算的结果为：‘, result2)
# 例1-62
def func6(a, b = 2):
print(a, b)
func6(1)
def func7(string, *numbers):
print(string, numbers)
func7(‘numbers:‘, 1, 2, 3)
def func8(a, *numbers, **kwargs):
print (a, numbers, kwargs)
func8(4, 2, 3, 4, b = 2, c = 3)
# 例1-63
x = 99
def func9(y):
return x + y
print(‘y = 1, x + y为：‘, func9(1))
def func10(y):
x = 12
return x + y
print(‘x为：‘, x, ‘
‘,
‘y=1, x+y为：‘, func10(1))
# 例1-64
x, y, z = 0, 2, 3
def func11():
x = 1
print(‘x + y与z是否相等：‘, x + y == z)
# 调用函数
func11()
print(‘x + y与z是否相等：‘, x + y == z)
def func12():
global x
x = 1
print(‘x + y与z是否相等：‘, x + y == z)
# 调用函数
func12()
print(‘x + y与z是否相等：‘, x + y == z)
# 例1-65
x = 1
list1 = [1, 2]
def func13(x,y):
x = 2
y[0] = ‘str‘
func13(x, list1)
print(‘调用函数后传入的参数变化为：‘, x, list1)
# 例1-66
sum1 = lambda arg1, arg2: arg1 + arg2
print("相加值为：", sum1(10, 20))
# 使用lambda语句
print(list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])))
f1 = lambda x: ‘传入的参数为1‘ if x == 1 else ‘传入的参数不为1‘
f1(10)
# #1. 输入一个包含若干自然数的列表，输出这些数的平均值，结果保留3位小数。
# data=eval(input(‘请输入一个包含若干自然数的列表:‘))
# avg=sum(data)/len(data)
# avg=round(avg,3)
# print(‘平均值为：‘,avg)
# #2. 输入一个包含若干自然数的列表，输出一个新列表，新列表中每个元素为原列表中每个自然数的位数。
# data=eval(input(‘请输入一个包含若干自然数的列表:‘))
# data=map(str,data)
# length=list(map(len,data))
# print(‘每个元素的位数：‘,length)
# #3. 输入一个字符串，输出其中每个唯一字符最后一次出现的下标。
# text=input(‘请输入一个字符串:‘)
# positions=[(ch,index) for index,ch in enumerate(text) if (index==text.rindex(ch)) and (text.count(ch)==1)]
# print(positions)
# #4. 输入一个字符串，检查该字符串是否为回文，输出yes / no，要求用切片实现。
# text=input(‘请输入一个字符串:‘)
# if text==text[::-1]:
# print(‘yes‘)
# else:
# print(‘no‘)
# #5. 接收两个正整数参数n和a（要求a为小于10的自然数），计算形如a+aa+aaa+…+aaa...aaa的表达式前n项的值。
# def compute(n,a):
# return(sum(map(lambda i:int(str(a)*i),range(1,n+1))))
# print(compute(3,5))
# 例3-1
import numpy as np
print(‘整数42转换为浮点数结果为：‘, np.float64(42))
print(‘浮点数42.0转换为整数结果为：‘, np.int8(42.0))
print(‘浮点数42转换为布尔型转换结果为：‘, np.bool(42.0))
print(‘整数0转换为布尔型结果为：‘, np.bool(0))
print(‘布尔型数据True转换为浮点数结果为：‘, np.float(True))
print(‘布尔型数据False转换为整型结果为：‘, np.int8(False))
#例3-2
arr1 = np.array([1, 2, 3, 4])
print(‘创建的一维ndarray为：‘, arr1)
arr2 = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])
print(‘创建的二维ndarray为：
‘, arr2)
print(‘ndarray arr2的维数为：‘, arr2.ndim)
print(‘ndarray arr2的形状为：‘, arr2.shape)
print(‘ndarray arr2的数据类型为：‘, arr2.dtype)
print(‘ndarray arr2的元素个数为：‘, arr2.size)
print(‘ndarray arr2每个元素的大小为：‘, arr2.itemsize)
# 代码 3-3
print(‘使用arange函数创建的ndarray为：‘, np.arange(0, 1, 0.1))
print(‘使用linspace函数创建的ndarray为：
‘,np.linspace(0, 1, 12))
print(‘使用logspace函数创建的ndarray为：
‘, np.logspace(0, 2, 20))
print(‘使用zeros函数创建的ndarray为：
‘, np.zeros((2, 3)))
print(‘使用eye函数创建的ndarray为：
‘, np.eye(3))
print(‘使用diag函数创建的ndarray为：
‘,np.diag([1, 2, 3, 4]))
print(‘使用ones函数的ndarray为：
‘, np.ones((2, 3)))
# 代码 3-4
print(‘random函数生成的随机数ndarray为：
‘, np.random.random(100))
print(‘rand函数生成的服从均匀分布的随机数ndarray为：
‘, np.random.rand(4, 5))
print(‘randn函数生成的服从正态分布的随机数ndarray为：
‘, np.random.randn(4, 5))
print(‘randint函数生成的指定上下限的随机整数ndarray为：
‘,
np.random.randint(low=2, high=10, size=[2, 5]))
# 代码 3-5
arr = np.arange(10)
print(‘使用元素位置索引结果为：‘, arr[5])
print(‘使用元素位置切片结果为：‘, arr[3:5])
print(‘省略单个位置切片结果为：‘, arr[:5])
print(‘使用元素反向位置切片结果为：‘, arr[:-1])
arr[2:4] = 100, 101 # 修改对应下标的值
print(‘修改后的ndarray arr为：‘, arr)
print(‘元素位置等差索引结果为：‘, arr[1:-1:2])
# 步长为负数时，开始位置必须大于结束位置
print(‘元素位置负数步长等差索引结果为：‘, arr[5:1:-2])
# 代码 3-6
arr = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print(‘创建的二维ndarray arr为：
‘, arr)
print(‘切片结果为：‘, arr[0, 3:5]) # 访问第0行中第3和第4列的元素
print(‘切片结果为：
‘, arr[1:, 2:]) # 访问第1和第2行中第2列、第3列和第4列的元素
print(‘切片结果为：
‘, arr[:, 2]) # 访问第2列所有的元素
# 索引第1、3行中第2列的元素
mask = np.array([1, 0, 1], dtype=np.bool)
print(‘使用布尔值ndarray索引结果为：‘, arr[mask, 2])
arr = np.empty((8, 4))
for i in range(8):
arr[i] = i
print(‘创建的二维ndarray arr为：
‘, arr)
print(‘以特定顺序索引arr结果为：
‘, arr[[4, 3, 0, 6]])
print(‘以特定逆序索引arr结果为：
‘, arr[[-3, -5, -7]])
arr = np.array([np.arange(i*4, i*4+4) for i in np.arange(6)])
print(‘创建的二维ndarray arr为：
‘, arr)
# 返回一个ndarray最终的元素(1,0)、(5,3)、(4,1)、(2,2)
print(‘使用二维ndarray索引arr结果为：‘, arr[[1, 5, 4, 2], [0, 3, 1, 2]])
# 代码 3-7
arr = np.arange(12) # 创建一维ndarray
print(‘创建的一维ndarray arr为：‘, arr)
arr1 = arr.reshape(3, 4) # 设置ndarray的维度
print(‘改变形状后的ndarray arr1为：
‘, arr1)
print(‘形状改变后ndarray arr1的维度为：‘, arr1.ndim)
# 代码 3-7
arr.resize(2, 6)
print(‘resize改变原ndarray形状，ndarray arr变为：
‘, arr)
arr.shape = (4, 3)
print(‘通过重新设置shape属性后，ndarray arr为：
‘, arr)
# 代码 3-8
arr = np.arange(12).reshape(3, 4)
print(‘创建的二维ndarray arr为：
‘, arr)
print(‘ndarray arr横向展平后为：‘, arr.ravel())
# 代码 3-8
print(‘ndarray arr使用flatten方法横向展平后为：‘, arr.flatten())
print(‘ndarray arr使用flatten方法纵向展平后为：‘, arr.flatten(‘F‘))
# 代码 3-9
arr1 = np.arange(12).reshape(3, 4)
print(‘创建的ndarray arr1为：
‘, arr1)
arr2 = arr1*3
print(‘创建的ndarray arr2为：
‘, arr2)
print(‘hstack横向组合ndarray arr1与arr2为：
‘, np.hstack((arr1, arr2)))
print(‘vstack纵向组合ndarray arr1与arr2为：
‘, np.vstack((arr1, arr2)))
# 代码 3-9
print(‘concatenate横向组合arr1与arr2为：
‘, np.concatenate((arr1, arr2), axis=1))
print(‘concatenate纵向组合arr1与arr2为：
‘, np.concatenate((arr1, arr2), axis=0))
print(‘dstack深度组合arr1与arr2为：
‘, np.dstack((arr1, arr2)))
# 代码 3-10
arr = np.arange(16).reshape(4, 4)
print(‘创建的二维ndarray arr为：
‘, arr)
print(‘hsplit横向分割arr为：
‘, np.hsplit(arr, 2))
print(‘hsplit纵向分割arr为：
‘, np.vsplit(arr, 2))
print(‘split横向分割arr为：
‘, np.split(arr, 2, axis=1))
print(‘split纵向分割arr为：
‘, np.split(arr, 2, axis=0))
# 代码 3-11
np.random.seed(42) #设置随机种子
arr = np.random.randint(1, 10, size=12).reshape(4, 3)
print(‘创建的随机数ndarray arr为：
‘, arr)
print(‘默认排序后ndarray arr为：
‘, np.sort(arr))
print(‘展平排序的ndarray arr为：‘, np.sort(arr, axis=None))
# 代码 3-11
print(‘横轴排序后ndarray arr为：
‘, np.sort(arr, axis=1))
print(‘纵轴排序后ndarray arr为：
‘, np.sort(arr, axis=0))
print(‘横轴排序后arr的下标为：
‘, np.argsort(arr, axis=1))
print(‘展平排序后arr的下标为：‘, np.argsort(arr, axis=None))
# 代码 3-12
arr = np.arange(6, 12).reshape(2, 3)
print(‘创建的ndarray arr为：
‘, arr)
print(‘ndarray arr中最大元素的索引为：‘, np.argmax(arr))
print(‘ndarray arr中最小元素的索引为：‘, np.argmin(arr))
# 代码 3-12
print(‘ndarray arr中各列最大元素的索引为：‘, np.argmax(arr, axis=0))
print(‘ndarray arr中各行最小元素的索引为：‘, np.argmin(arr, axis=1))
# 代码 3-13
arr = np.arange(12).reshape(4,3)
print(‘创建的ndarray arr为：
‘, arr)
print(‘where输出ndarray arr满足条件的下标为：
‘, np.where(arr>6))
arr1 = np.arange(12).reshape(3, 4)
print(‘创建的ndarray arr1为：
‘, arr1)
arr2 = np.arange(-12, 0).reshape(3, 4)
print(‘创建的ndarray arr2为：
‘, arr2)
exp = arr1>5
print(‘arr1大于5的布尔ndarray为：
‘, exp)
# 代码 3-13
print(‘where函数搜索符合条件的arr1与arr2为：
‘, np.where(exp, arr1, arr2))
arr = np.arange(9).reshape(3, 3)
print(‘创建的ndarray arr为：
‘, arr)
exp = (arr % 2) == 0
print(‘arr能被2整除的布尔ndarray为：
‘, exp)
print(‘arr基于条件exp提取的元素为：
‘, np.extract(exp, arr))
import numpy as np
x=np.array([1,2,3])
y=np.array([4,5,6])
print(x+y)
# 代码 3-15
import numpy as np
arr = np.arange(-4, 5).reshape(3, 3)
print(‘创建的ndarray arr为：
‘, arr)
print(‘ndarray arr各元素的相反数为：
‘, np.negative(arr))
print(‘ndarray arr各元素的绝对值为：
‘, np.absolute(arr))
print(‘ndarray arr各元素的符号为：
‘, np.sign(arr))
print(‘ndarray arr各元素的平方根为：
‘, np.sqrt(arr))
print(‘ndarray arr各元素的自然对数为：
‘, np.log(arr))
# 代码 3-16
arr = np.arange(20).reshape(4, 5)
print(‘创建的ndarray arr为：
‘, arr)
print(‘ndarray arr各元素的和为：‘, np.sum(arr))
print(‘ndarray arr各行的极差为：‘, np.ptp(arr, axis=1))
print(‘ndarray arr各列的均值为：‘, np.mean(arr, axis=0))
print(‘ndarray arr的中位数为：‘, np.median(arr))
# 代码 3-16
print(‘ndarray arr各行的上四分位数为：‘,np.percentile(arr, 75, axis =1))
print(‘ndarray arr各列的下四分位数为：‘, np.percentile(arr, 25, axis =0))
print(‘ndarray arr的标准差为：‘, np.std(arr))
print(‘ndarray arr的方差为：‘, np.var(arr))
print(‘ndarray arr的最小值为：‘, np.min(arr))
print(‘ndarray arr的最大值为：‘, np.max(arr))
# 代码 3-17
arr = np.arange(1, 11)
print(‘创建的ndarray arr为：‘, arr)
print(‘ndarray arr的元素累计和为：‘, np.cumsum(arr))
print(‘ndarray arr的元素累计积为：
‘, np.cumprod(arr))
# # 代码 3-18
# import numpy as np
# arr = np.load(‘../data/arr.npy‘)
# print(‘从二进制文件arr.npy读取的ndarray arr为：
‘, arr)
# arr1 = np.load(‘../data/arr.npz‘)
# print(‘从二进制文件arr.npz读取的第1个ndarray为：
‘, arr1[‘arr_0‘])
# print(‘从二进制文件arr.npz读取的第2个ndarray为：
‘, arr1[‘arr_1‘])
# # 代码 3-19
# np.random.seed(123)
# arr = np.random.rand(25).reshape(5, 5)
# print(‘创建的ndarray arr为：
‘, arr)
# np.save(‘../tmp/save_arr.npy‘, arr)
# print(‘……存储成功……‘)
# # 代码 3-20
# arr1 = np.random.rand(36).reshape(6, 6)
# print(‘创建的ndarray arr1为：
‘, arr1)
# arr2 = np.random.rand(16).reshape(4, 4)
# print(‘创建的ndarray arr2为：
‘, arr2)
# np.savez(‘../tmp/save_arr.npz‘, arr1, arr2)
# # 代码 3-20
# arr3 = np.load(‘../tmp/save_arr.npz‘)
# print(‘存取的第1个ndarray为：
‘, arr3[‘arr_0‘])
# np.savez(‘../tmp/save_kwds.npz‘, x=arr1, y=arr2)
# arr4 = np.load(‘../tmp/save_kwds.npz‘)
# print(‘存取的第2个ndarray为：
‘, arr4[‘y‘])
# # 代码 3-21
# # 指定分隔符读入文本文件
# arr = np.loadtxt("../data/arr.txt", delimiter=",")
# print(‘读取的ndarray arr为：
‘, arr1)
# arr = np.arange(36).reshape(6, 6)
# print(‘创建的ndarray arr为：‘, arr)
# np.savetxt("../tmp/savetxt.txt", arr, fmt="%d", delimiter=",")
# print(‘……存储成功……‘)
# 代码 3-23
import pandas as pd
list1=[0,1,2,3,4]
series = pd.Series(list1, index = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘], name = ‘list‘)
print(‘Series位于第1位置的数据为：‘, series[0])
print(‘Series中Index为a的数据为：‘, series[‘a‘])
bool = (series < 4)
print(‘bool类型的Series为：
‘, bool)
print(‘通过bool数据访问Series结果为：
‘, series[bool])
# 代码 3-24
# 更新元素
series[‘a‘] = 3
print(‘更新后的Series为：
‘, series)
series1 = pd.Series([4, 5], index = [‘f‘, ‘g‘])
# 追加Series
print(‘在series插入series1后为：
‘, series.append(series1))
# 新增单个数据
series1[‘h‘] = 7
print(‘在series1插入单个数据后为：
‘, series1)
# 删除数据
series.drop(‘e‘, inplace = True)
print(‘删除索引e对应数据后的series为：
‘, series)
# 代码 3-25
dict1 = {‘col1‘: [0, 1, 2, 3, 4], ‘col2‘: [5, 6, 7, 8, 9]}
print(‘通过dict创建的DataFrame为：
‘, pd.DataFrame(dict1, index = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]))
list2 = [[0, 5], [1, 6], [2, 7], [3, 8], [4, 9]]
print(‘通过list创建的DataFrame为：
‘,
pd.DataFrame(list2, index = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘], columns = [‘col1‘, ‘col2‘]))
# 代码 3-26
df = pd.DataFrame({‘col1‘: [0, 1, 2, 3, 4], ‘col2‘: [5, 6, 7, 8, 9]},
index = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘])
print(df)
print(‘DataFrame的Index为：‘, df.index)
print(‘DataFrame的列标签为：‘, df.columns)
print(‘DataFrame的轴标签为：‘, df.axes)
print(‘DataFrame的维度为：‘, df.ndim)
print(‘DataFrame的形状为：‘, df.shape)
# 代码 3-28
# 更新列
df[‘col1‘] = [10, 11, 12, 13, 14]
print(‘更新列后的DataFrame为：
‘, df)
# 插入列
df[‘col3‘] = [15, 16, 17, 18, 19]
print(‘插入列后的DataFrame为：
‘, df)
# 代码 3-28
# 删除列
df.drop([‘col3‘], axis = 1, inplace = True)
print(‘删除col3列后的DataFrame为：
‘, df)
# 删除行
df.drop(‘a‘, axis = 0, inplace = True)
print(‘删除a行后的DataFrame为：
‘, df)
# 代码 3-29
df = pd.DataFrame({‘col1‘: [0, 1, 2, 3, 4], ‘col2‘: [5, 6, 7, 8, 9]}, index = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘])
print(‘创建的DataFrame为：
‘, df)
# 访问单列数据
print(‘DataFrame中col1列数据为：
‘, df[‘col1‘])
# 以属性的方式访问单列数据
print(‘DataFrame中col1列数据为：
‘, df.col1)
# 代码3-30
# 访问单列多行数据
print(‘DataFrame中col1列前3行数据为：
‘, df[‘col1‘][0: 3])
# 访问多列多行数据
print(‘DataFrame中col1列、col2列前3行数据为：
‘, df[[‘col1‘, ‘col2‘]][0: 3])
# 访问多行数据
print(‘DataFrame的前3行为：
‘, df[: ][0: 3])
# 代码 3-31
# 访问单列数据
print(‘DataFrame中col1列数据为：
‘, df.loc[: , ‘col1‘])
# 访问多列数据
print(‘DataFrame中col1列、col2数据为：
‘, df.loc[: , [‘col1‘, ‘col2‘]])
# 访问单行数据
print(‘DataFrame中a行对应数据为：
‘, df.loc[‘a‘, :])
# 访问多行数据
print(‘DataFrame中a行、b行对应数据为：
‘, df.loc[[‘a‘, ‘b‘], :])
# 行列结合访问数据
print(‘DataFrame中a行、b行，col1列、col2列对应的数据为：
‘,
df.loc[[‘a‘, ‘b‘], [‘col1‘, ‘col2‘]])
# 接收bool数据
print(‘DataFrame中col1列大于0的数据为：
‘, df.loc[df[‘col1‘] > 0, :])
# 接收函数
print(‘DataFrame中col1列大于0的数据为：
‘, df.loc[lambda df: df[‘col1‘] > 0, :])
# 代码 3-32
# 访问单列数据
print(‘DataFrame中col1列数据为：
‘, df.iloc[: , 0])
# 访问多列数据
print(‘DataFrame中col1列、col2列数据为：
‘, df.iloc[: , [0, 1]])
# 访问单行数据
print(‘DataFrame中a行数据为：
‘, df.iloc[0, :])
# 访问多行数据
print(‘DataFrame中a行、b行数据为：
‘, df.iloc[[0, 1], :])
# 行列结合访问数据
print(‘DataFrame中a行、b行，col1列、col2列数据为：
‘, df.iloc[[0, 1], [0, 1]])
# 代码 3-33
multiindex = [[‘bar‘, ‘bar‘, ‘baz‘, ‘baz‘, ‘foo‘, ‘foo‘, ‘qux‘, ‘qux‘],
[‘one‘, ‘two‘, ‘one‘, ‘two‘, ‘one‘, ‘two‘, ‘one‘, ‘two‘]]
df1 = pd.DataFrame(np.arange(16).reshape(8, 2),
index=multiindex, columns=[‘column1‘, ‘column2‘])
print(‘创建的DataFrame为:
‘, df1)
print(‘DataFrame的层次化索引为:
‘, df1.index)
# 代码 3-34
print(‘访问DataFrame第1索引层bar，第2索引层two结果为：
‘,
df1.loc[(‘bar‘, ‘two‘), :])
print(‘访问DataFrame第1索引层bar、baz、foo，第2索引层one、two结果为：
‘,
df1.loc[([‘bar‘, ‘baz‘, ‘foo‘], [‘one‘, ‘two‘]), :])
print(‘访问DataFrame第1索引层bar、baz、foo，第2索引层one、two结果为：
‘,
df1.loc[(slice(‘bar‘, ‘foo‘), slice(None)), :])
# 代码 3-35
# 接收单个标签
idx = pd.IndexSlice
print(‘访问DataFrame第1索引层bar，第2索引层two结果为：
‘, df1.loc[idx[‘bar‘, ‘two‘], :])
# 接收标签list
print(‘访问DataFrame第1索引层bar、foo，第2索引层two结果为：
‘,
df1.loc[idx[[‘bar‘, ‘foo‘], ‘two‘], :])
# 接收标签切片
print(‘访问DataFrame第1索引层bar到foo，第2索引层two结果为：
‘,
df1.loc[idx[‘bar‘: ‘foo‘, ‘one‘], :])
# 接收bool数组
con = df1[‘column1‘]>0
print(‘访问DataFrame第1索引层bar到foo，第二索引层对应的‘
‘column1列大于0结果为：
‘,df1.loc[idx[‘bar‘: ‘foo‘, con], :])
# 代码 3-36
# 按行索引排序
print(‘按行索引排序后的DataFrame为：
‘, df.sort_index(axis = 0))
# 按列索引降序排列
print(‘按列索引降序排列后的DataFrame为：
‘, df.sort_index(axis = 1, ascending = False))
# 按列排序
print(‘按col2列排序后的DataFrame为：
‘, df.sort_values(‘col2‘))
# 按行降序排列
print(‘按列降序排列后的DataFrame为：
‘, df.sort_values(‘a‘, axis = 1, ascending = False))
print(‘按col2列排序,返回前2个最小值：
‘, df.nsmallest(2, ‘col2‘))
print(‘按col2列排序,返回前2个最大值：
‘, df.nlargest(2, ‘col2‘))
# 代码 3-37
df2 = pd.DataFrame({‘key‘: [‘K0‘, ‘K1‘, ‘K2‘, ‘K3‘, ‘K4‘, ‘K5‘],
‘A‘: [‘A0‘, ‘A1‘, ‘A2‘, ‘A3‘, ‘A4‘, ‘A5‘]})
df3 = pd.DataFrame({‘key‘: [‘K0‘, ‘K1‘, ‘K2‘], ‘B‘: [‘B0‘, ‘B1‘, ‘B2‘]})
# 横向堆叠df2、df3
print(‘横向堆叠df2、df3后的DataFrame为：
‘, pd.concat([df2, df3], axis = 1))
# 横向堆叠（内连）df2、df3
print(‘横向堆叠（内连）df2、df3后的DataFrame为：
‘,
pd.concat([df2, df3], axis = 1, join = ‘inner‘))
# 代码 3-38
print(‘横向堆叠df2、df3后的DataFrame为：
‘, df2.join(df3, rsuffix = ‘_2‘))
# 纵向堆叠df2、df3
print(‘纵向堆叠df2、df3后的DataFrame为：
‘, pd.concat([df2, df3], axis = 0))
# 纵向堆叠（内连）df2、df3
print(‘纵向堆叠（内连）df2、df3后的DataFrame为：
‘,
pd.concat([df2, df3], axis = 0, join = ‘inner‘))
print(‘纵向堆叠df2、df3后的DataFrame为：
‘, df2.append(df3))
# 代码 3-39
print(‘以列key为键，内连df2、df3后的DataFrame为：
‘,
pd.merge(df2, df3, on = ‘key‘, how = ‘inner‘))
# # 代码 3-40
# df = pd.read_csv(‘../data/meal_order_info.csv‘, encoding = ‘gbk‘)
# print(‘读取的CSV文件前5行数据为：
‘, df.head())
# # 代码 3-42
# df = pd.read_excel(‘../data/users_info.xlsx‘, encoding = ‘gbk‘)
# print(‘读取的Excel文件前5行数据为：
‘, df.head())
# 代码 3-43
import matplotlib.pyplot as plt
X=np.random.randn(100)
Y=np.random.randn(100)
plt.scatter(X,Y)
#代码3-44
years=[1950,1960,1970,1980,1990,2000,2010]
gdp=[300.2,543.3,1075.9,2862.5,5979.6,10289.7,14958.3]
plt.plot(years,gdp,color=‘r‘)
#代码3-45
data=np.random.randint(1,10,10)
data
plt.pie(data)
#代码3-46
x=np.random.normal(size=100)
plt.hist(x,bins=30)
#代码3-47
data=[23,85,72,43,52]
plt.bar([1,2,3,4,5],data)
#代码3-48
list10=np.random.randint(1,100,10)
plt.boxplot(list10)
# 代码 3-42
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure(figsize = (6, 6), dpi = 80) # 创建画布。大小为6×6，像素为80
x = np.linspace(0, 1, 1000)
fig.add_subplot(2, 1, 1) # 分为2×1图形阵，选择第1张图片绘图
plt.title(‘y=x^2 & y=x‘) # 添加标题
plt.xlabel(‘x‘) # 添加x轴名称‘x’
plt.ylabel(‘y‘) # 添加y轴名称‘y’
plt.xlim((0, 1)) # 指定x轴范围（0,1）
plt.ylim((0, 1)) # 指定y轴范围（0,1）
plt.xticks([0, 0.3, 0.6, 1]) # 设置x轴刻度
plt.yticks([0, 0.5, 1]) # 设置y轴刻度
plt.plot(x, x ** 2)
plt.plot(x, x)
plt.legend([‘y=x^2‘, ‘y=x‘]) # 添加图例
#代码3-49
fig=plt.figure(figsize=(10,6))
ax1=fig.add_subplot(2,2,1)
ax2=fig.add_subplot(2,2,2)
ax3=fig.add_subplot(2,2,3)
ax4=fig.add_subplot(2,2,4)
ax1.scatter(years,gdp)
ax2.plot(years,gdp)
ax3.bar(years,gdp)
ax4.hist(years,gdp)
# 三维曲面
import matplotlib.pyplot as plt
import numpy as np
x,y=np.mgrid[-2:2:20j,-2:2:20j]
z=50*np.sin(x+y*2)
ax=plt.subplot(111,projection=‘3d‘)
ax.plot_surface(x,y,z,rstride=3,cstride=2,cmap=plt.cm.coolwarm)
ax.set_xlabel(‘X‘)
ax.set_ylabel(‘Y‘)
ax.set_zlabel(‘Z‘)
# 三维柱状图
x=np.random.randint(0,40,10)
y=np.random.randint(0,40,10)
z=80*abs(np.sin(x+y))
ax=plt.subplot(projection=‘3d‘)
ax.bar3d(x,y,np.zeros_like(z),dx=1,dy=1,dz=z,color=‘red‘)
ax.set_xlabel(‘X‘)
ax.set_ylabel(‘Y‘)
ax.set_zlabel(‘Z‘)
# 三维散点图
x=np.random.randint(0,40,30)
y=np.random.randint(0,40,30)
z=np.random.randint(0,40,30)
ax=plt.subplot(projection=‘3d‘)
for xx,yy,zz in zip(x,y,z):
color=‘r‘
if 10<zz<20:
color=‘b‘
elif zz>=20:
color=‘g‘
ax.scatter(xx,yy,zz,c=color,marker=‘*‘,s=160,linewidth=1,edgecolor=‘b‘)
ax.set_xlabel(‘X‘)
ax.set_ylabel(‘Y‘)
ax.set_zlabel(‘Z‘)
#代码4-1
import pandas as pd
df = pd.read_html(‘http://worldcup.2014.163.com/schedule/‘)
# #代码4-2
# import requests
# from bs4 import BeautifulSoup
# data = []
# wb_data = requests.get(‘http://www.kugou.com/yy/rank/home/1-8888.html‘)
# soup = BeautifulSoup(wb_data.text,‘lxml‘)
# ranks = soup.select(‘span.pc_temp_num‘)
# titles = soup.select(‘div.pc_temp_songlist > ul > li > a‘)
# times = soup.select(‘span.pc_temp_tips_r > span‘)
# for rank,title,time in zip(ranks,titles,times):
# a = {
# ‘rank‘:rank.get_text().strip(),
# ‘singer‘:title.get_text().split(‘-‘)[0],
# ‘song‘:title.get_text().split(‘-‘)[1],
# ‘time‘:time.get_text().strip()
# }
# data.append(a)
# #代码4-3
# import json
# f = open(‘D:/data/eueo2012.json‘)
# obj = f.read()
# result = json.loads(obj)
# result
# 代码4-5
import numpy as np
df1=pd.DataFrame([[3,5,3],[1,6,np.nan],[‘lili‘,np.nan,‘pop‘],[np.nan,‘a‘,‘b‘]])
print(df1.isnull().sum())
df1.isnull().sum().sum()
#代码4-7
data={‘name‘:[‘张飒‘,‘李苏‘,‘张飒‘,‘万明‘], ‘sex‘:[‘female‘,‘male‘,‘female‘,‘male‘],
‘year‘:[2001,2002,2001,2002],
‘city‘:[‘北京‘,‘上海‘,‘北京‘,‘北京‘]}
df3=pd.DataFrame(data)
df3.duplicated()
df3.drop_duplicates()
df3.drop_duplicates(keep=‘last‘)
#代码4-8
data1={‘name‘:[‘张飒‘,‘李苏‘,‘张飒‘,‘万明‘],
‘sex‘:[‘female‘,‘male‘,‘‘,‘male‘],
‘year‘:[2001,2002,2001,2002],
‘city‘:[‘北京‘,‘上海‘,‘‘,‘北京‘]}
df4=pd.DataFrame(data1)
df4.replace(‘‘,‘不详‘)
df4.replace([‘‘,2001],[‘不详‘,2002])
df4.replace({‘‘:‘不详‘,2001:2002})
#代码4-9
data2={‘name‘:[‘张三‘,‘李四‘,‘王五‘,‘小明‘],
‘math‘:[79,52,63,92]}
df5=pd.DataFrame(data2)
def f(x):
if x>=90:
return ‘优秀‘
elif x>=70:
return ‘良好‘
elif x>=60:
return ‘合格‘
else:
return ‘不合格‘
df5[‘class‘]=df5[‘math‘].map(f)
#代码4-10
df6=pd.DataFrame(np.arange(10),columns=[‘X‘])
df6[‘Y‘]=2*df6[‘X‘]+0.5
df6.iloc[9,1]=185
df6.plot(kind=‘scatter‘,x=‘X‘,y=‘Y‘)
#代码4-11
df7=pd.DataFrame({‘朝向‘:[‘东‘,‘南‘,‘东‘,‘西‘,‘北‘],
‘价格‘:[1200,2100,2300,2900,1400]})
pd.get_dummies(df7[‘朝向‘])
#代码4-12
from pandas import Series
df8=pd.DataFrame({‘朝向‘:[‘东/北‘,‘西/南‘,‘东‘,‘西/北‘,‘北‘],
‘价格‘:[1200,2100,2300,2900,1400]})
dummy=df8[‘朝向‘].apply(lambda x:Series(x.split(‘/‘)).value_counts())
#代码4-13
price=pd.DataFrame({‘fruit‘:[‘apple‘,‘banana‘,‘orange‘],
‘price‘:[23,32,45]})
amount=pd.DataFrame({‘fruit‘:[‘apple‘,‘banana‘,‘apple‘,‘apple‘,‘banana‘,‘pear‘],
‘amount‘:[5,3,6,3,5,7]})
pd.merge(amount,price)
pd.merge(amount,price,how=‘left‘)
pd.merge(amount,price,how=‘right‘)
pd.merge(amount,price,how=‘outer‘)
#代码4-14
s1=Series([0,1],index=[‘a‘,‘b‘])
s2=Series([2,3],index=[‘c‘,‘d‘])
s3=Series([4,5],index=[‘e‘,‘f‘])
pd.concat([s1,s2,s3])
pd.concat([s1,s2,s3],axis=1)
#代码4-15
import pandas as pd
import numpy as np
df10=pd.DataFrame({‘a‘:[3.0,np.nan,6.0,np.nan],‘b‘:[np.nan,4.0,6.0,np.nan]})
df11=pd.DataFrame({‘a‘:[0,1,2,3,4],‘b‘:[0,1,2,3,4]})
df10.combine_first(df11)
df10=pd.DataFrame({‘a‘:[3.0,np.nan,6.0,np.nan],‘b‘:[np.nan,4.0,6.0,np.nan]})
df11=pd.DataFrame({‘a‘:[0,1,2,3,4],‘b‘:[0,1,2,3,4]})
df10.combine_first(df11)
#代码4-16
from pandas import Series,DataFrame
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import seaborn as sns #导入seaborn绘图库
iris_data = pd.read_csv(open(r‘E:资料数据集seaborn-data-masteriris.csv‘))
iris_data.head()
iris_data.shape
iris_data.describe()
# iris_data[‘class‘].unique()
# iris_data.ix[iris_data[‘class‘] == ‘versicolor‘, ‘class‘] = ‘Iris-versicolor‘
# iris_data.ix[iris_data[‘class‘] == ‘Iris-setossa‘, ‘class‘] = ‘Iris-setosa‘
# iris_data[‘class‘].unique()
# sns.pairplot(iris_data, hue=‘class‘)
# iris_data.ix[iris_data[‘class‘] == ‘Iris-setosa‘, ‘sepal_width_cm‘].hist()
# iris_data = iris_data.loc[(iris_data[‘class‘] != ‘Iris-setosa‘) | (iris_data[‘sepal_width_cm‘] >= 2.5)]
# iris_data.loc[iris_data[‘class‘] == ‘Iris-setosa‘, ‘sepal_width_cm‘].hist()
# iris_data.loc[(iris_data[‘class‘] == ‘Iris-versicolor‘) &
# (iris_data[‘sepal_length_cm‘] < 1.0)]
# iris_data.loc[(iris_data[‘class‘] == ‘Iris-versicolor‘) &
# (iris_data[‘sepal_length_cm‘] < 1.0),
# ‘sepal_length_cm‘] *= 100.0
# iris_data.isnull().sum()
# iris_data[iris_data[‘petal_width_cm‘].isnull()]
# iris_data.dropna(inplace=True)
# iris_data.to_csv(‘H:python数据分析数据iris-clean-data.csv‘, index=False)
# iris_data = pd.read_csv(open(‘H:python数据分析数据iris-clean-data.csv‘))
# iris_data.head()
# iris_data.shape
# sns.pairplot(iris_data, hue=‘class‘)
# iris_data.boxplot(column=‘petal_length_cm‘, by=‘class‘,grid=False,figsize=(6,6))
# # 代码 4-17
# import pandas as pd
# import numpy as np
# df = pd.read_csv(‘D:/data/Concrete.csv‘, encoding = ‘gbk‘)
# print(‘数据框df每列对应的最大值为：
‘, np.max(df), ‘
‘, ‘数据框df每列对应的最小值为：
‘, np.min(df))
# print(‘数据框df每列对应的均值为：
‘, np.mean(df))
# print(‘数据框df对应的中位数为：‘, np.median(df))
# print(‘数据框df每列对应的标准差为：
‘, np.std(df))
# print(‘数据框df每列对应的方差为：
‘, np.var(df))
# # 代码 4-18
# print(‘数据框df每列对应的最大值为：
‘, df.max(), ‘
‘,‘数据框df每列对应的最小值为：
‘, df.min())
# print(‘数据框df每列对应的均值为：
‘, df.mean())
# print(‘数据框df每列对应的中位数为：
‘, df.median())
# print(‘数据框df每列对应的标准差为：
‘, df.std())
# print(‘数据框df每列对应的方差为：
‘, df.var())
# print(‘使用describe方法的描述性统计结果为：
‘, df.describe())
# # 代码 4-19
# df1 = pd.DataFrame({‘col1‘: list(‘abca‘), ‘col2‘: list(‘bccd‘)}, dtype = ‘category‘)
# print(‘使用describe方法的描述性统计结果为：
‘, df1.describe())
# print(‘DataFrame的info信息为：
‘)
# df.info()
# # 代码 4-20
# station = pd.read_csv(‘D:/data/Station.csv‘, encoding = ‘gbk‘)
# group = station.groupby(‘station‘)
# print(‘以station为分组键，创建的GroupBy对象为：
‘, group)
# print(‘分组数据的均值前5行结果为：
‘, group.mean().head())
# print(‘分组数据的和前5行结果为：
‘,group.sum().head())
# print(‘分组数据的最大值前5行结果为：
‘,group.max().head())
# # 代码 4-21
# print(‘分组的均值前5行结果为：
‘, group.agg(np.mean).head())
# def f(x):
# return x.max() - x.min()
# group1 = group.agg(f)
# print(‘分组的极差前5行结果为：
‘, group1.head())
# group2 = group.agg([np.mean, np.sum])
# print(‘分组的均值和总和前5行结果为：
‘, group2.head())
# group3 = group.agg({‘on_man‘: np.mean, ‘off_man‘: np.sum})
# print(‘列on_man应用均值函数，列off_man应用汇总函数前5行结果为：
‘, group3.head())
# # 代码 4-22
# print(‘分组的均值前5行结果为：
‘, group.apply(np.mean).head())
# def f(x):
# result = x[0: 2]
# return result
# print(‘分组的前两个数据前5行结果为：
‘, group.apply(f).head())
# # 代码 4-23
# print(‘对分组应用均值函数，返回的DataFrame前5行数据为：
‘,
# group.transform(np.mean).head())
# def f(x):
# result = x*2
# return result
# print(‘对分组的每个元组乘以2，返回的DataFrame前5行数据为：
‘, group.transform(f).head())
# 代码 4-24
dit = {‘one‘: [‘a‘, ‘b‘, ‘b‘, ‘b‘, ‘a‘], ‘two‘: [0, 1, 2, 3, 4],
‘three‘: [5, 6, 7, 8, 9], ‘four‘: [‘x‘, ‘x‘, ‘y‘, ‘y‘, ‘y‘]}
df = pd.DataFrame(dit)
tdf = pd.pivot_table(df, index=[‘four‘], columns=[‘one‘])
print(‘创建的透视表为：
‘, tdf)
tdf = pd.pivot_table(df, index=[‘four‘], columns=[‘one‘], aggfunc = np.sum)
print(‘分组和的透视表为：
‘, tdf)
# 代码 4-25
cdf = pd.crosstab(index = df[‘four‘], columns = df[‘one‘])
print(‘创建的交叉表为：
‘, cdf)
cdf = pd.pivot_table(df, values = ‘two‘, index = [‘four‘], columns = [‘one‘],
aggfunc = (lambda x: len(x)))
print(‘使用pivot_table函数创建的交叉表为：
‘, cdf)
导包
import numpy as np
创建二维数组
x = np.matrix([[1,2,3],[4,5,6]])
创建一维数组
y = np.matrix([1,2,3,4,5,6])
x 的第二行第二列元素
x[1,1]
矩阵的乘法
x*y
复制代码
# 相关系数矩阵,可使用在列表元素数组矩阵
# 负相关
np.corrcoef([1,2,3],[8,5,4])
‘‘‘
array([[ 1. , -0.96076892],
[-0.96076892, 1. ]])
‘‘‘
# 正相关
np.corrcoef([1,2,3],[4,5,7])
‘‘‘
array([[1. , 0.98198051],
[0.98198051, 1. ]])
‘‘‘
复制代码
矩阵的方差
np.cov([1,1,1,1,1])
矩阵的标准差
np.std([1,1,1,1,1])
垂直堆叠矩阵
z = np.vstack((x,y))
矩阵的协方差
np.cov(z)
np.cov(x,y)
标准差
np.std(z)
列向标准差
np.std(z,axis = 1)
方差
np.cov(x)
特征值和特征向量
A = np.array([[1,-3,3],[3,-5,3],[6,-6,4]])
e,v = np.linalg.eig(A)
e 为特征值, v 为特征向量
矩阵与特征向量的乘积
np.dot(A,v)
特征值与特征向量的乘积
e * v
验证两个乘积是否相等
np.isclose(np.dot(A,v),(e * v))
行列式 |A - λE| 的值应为 0
np.linalg.det(A-np.eye(3,3)*e)
逆矩阵
y = np.linalg.inv(x)
复制代码
矩阵的乘法(注意先后顺序)
x * y
‘‘‘
matrix([[ 1.00000000e+00, 5.55111512e-17, 1.38777878e-17],
[ 5.55111512e-17, 1.00000000e+00, 2.77555756e-17],
[ 1.77635684e-15, -8.88178420e-16, 1.00000000e+00]])
‘‘‘
y * x
‘‘‘
matrix([[ 1.00000000e+00, -1.11022302e-16, 0.00000000e+00],
[ 8.32667268e-17, 1.00000000e+00, 2.22044605e-16],
[ 6.93889390e-17, 0.00000000e+00, 1.00000000e+00]])
‘‘‘
复制代码
求解线性方程组
a = np.array([[3,1],[1,2]])
b = np.array([9,8])
x = np.linalg.solve(a,b)
最小二乘解：返回解，余项，a 的秩，a 的奇异值
np.linalg.lstsq(a,b)
# (array([2., 3.]), array([], dtype=float64), 2, array([3.61803399, 1.38196601]))
复制代码
计算向量和矩阵的范数
x = np.matrix([[1,2],[3,-4]])
np.linalg.norm(x)
# 5.477225575051661
np.linalg.norm(x,-2)
# 1.9543950758485487
np.linalg.norm(x,-1)
# 4.0
np.linalg.norm(x,1)
# 6.0
np.linalg.norm([1,2,0,3,4,0],0)
# 4.0
np.linalg.norm([1,2,0,3,4,0],2)
# 5.477225575051661
复制代码
复制代码
奇异值分解
a = np.matrix([[1,2,3],[4,5,6],[7,8,9]])
u,s,v = np.linalg.svd(a)
u
‘‘‘
matrix([[-0.21483724, 0.88723069, 0.40824829],
[-0.52058739, 0.24964395, -0.81649658],
[-0.82633754, -0.38794278, 0.40824829]])
‘‘‘
s
‘‘‘
array([1.68481034e+01, 1.06836951e+00, 4.41842475e-16])
‘‘‘
v
‘‘‘
matrix([[-0.47967118, -0.57236779, -0.66506441],
[-0.77669099, -0.07568647, 0.62531805],
[-0.40824829, 0.81649658, -0.40824829]])
‘‘‘
# 验证
u * np.diag(s) * v
‘‘‘
matrix([[1., 2., 3.],
[4., 5., 6.],
[7., 8., 9.]])
‘‘‘
复制代码
实现矩阵的转置
x.T
元素平均值
x.mean()
纵向平均值
x.mean(axis = 0)
横向平均值
x.mean(axis = 1)
所有元素之和
x.sum()
横向最大值
x.max(axis = 1)
横向最大值的索引下标
x.argmax(axis = 1)
对角线元素
x.diagonal()
非零元素下标
x.nonzero()
创建数组
np.array([1,2,3,4])
np.array((1,2,3,4))
np.array(range(4)) # 不包含终止数字
# array([0, 1, 2, 3])
# 使用 arange(初始位置=0,末尾,步长=1)
np.arange(1,8,2)
# array([1, 3, 5, 7])
生成等差数组,endpoint 为 True 则包含末尾数字
np.linspace(1,3,4,endpoint=False)
# array([1. , 1.5, 2. , 2.5])
np.linspace(1,3,4,endpoint=True)
# array([1. , 1.66666667, 2.33333333, 3. ])
创建全为零的一维数组
np.zeros(3)
创建全为一的一维数组
np.ones(4)
np.linspace(1,3,4)
# array([1. , 1.66666667, 2.33333333, 3. ])
复制代码
np.logspace(起始数字，终止数字，数字个数，base = 10) 对数数组
np.logspace(1,3,4)
# 相当于 10 的 linspace(1,3,4) 次方
# array([ 10. , 46.41588834, 215.443469 , 1000. ])
np.logspace(1,3,4,base = 2)
# 2 的 linspace(1,3,4) 次方
# array([2. , 3.1748021, 5.0396842, 8. ])
复制代码
创建二维数组(列表嵌套列表)
np.array([[1,2,3],[4,5,6]])
# 创建全为零的二维数组
# 两行两列
np.zeros((2,2))
三行两列
np.zeros((3,2))
复制代码
# 创建一个单位数组
np.identity(3)
‘‘‘
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
‘‘‘
复制代码
复制代码
创建一个对角矩阵，(参数为对角线上的数字)
np.diag((1,2,3))
‘‘‘
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
‘‘‘
复制代码
第一行元素
n[0]
第一行第三列元素
n[0,2]
第一行和第二行的元素
n[[0,1]]
第一行第三列，第三行第二列，第二行第一列
n[[0,2,1],[2,1,0]]
将数组倒序
a[::-1]
步长为 2
a[::2]
从 0 到 4 的元素
a[:5]
复制代码
变换 c 的矩阵行和列
c = np.arange(16)
# array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
c.shape = 4,4
‘‘‘
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
‘‘‘
复制代码
第一行，第三个元素到第五个元素(如果没有则输出到末尾截止)
c[0,2:5]
第二行元素
c[1]
第三行到第六行，第三列到第六列
c[2:5,2:5]
第二行第三列元素和第三行第四列元素
c[[1,2],[2,3]]
第一行和第三行的第二列到第三列的元素
c[[0,2],1:3]
第一列和第三列的所有横行元素
c[:,[0,2]]
第三列所有元素
c[:,2]
第二行和第四行的所有元素
c[[1,3]]
第一行的第二列，第四列元素，第四行的第二列，第四列元素
c[[0,3]][:,[1,3]]
使用 * 进行相乘
x*2
使用 / 进行相除
x / 2
2 / x
使用 // 进行整除
x//2
10//x
使用 ** 进行幂运算
x**3
2 ** x
使用 + 进行相加
x + 2
使用 % 进行取模
x % 3
使用 + 进行相加
np.array([1,2,3,4]) + np.array([11,22,33,44])
np.array([1,2,3,4]) + np.array([3])
# array([4, 5, 6, 7])
数组的内积运算(对应位置上元素相乘)
np.dot(x,y)
sum(x*y)
将数组中大于 0.5 的元素显示
n[n>0.5]
找到数组中 0.05 ~ 0.4 的元素总数
sum((n > 0.05)&(n < 0.4))
是否都大于 0.2
np.all(n > 0.2)
是否有元素小于 0.1
np.any(n < 0.1)
复制代码
在 a 中是否有大于 b 的元素
a > b
# array([False, True, False])
# 在 a 中是否有等于 b 的元素
a == b
# array([False, False, True])
# 显示 a 中 a 的元素等于 b 的元素
a[a == b]
# array([7])
复制代码
显示 a 中的偶数且小于 5 的元素
a[(a%2 == 0) & (a < 5)]
生成一个随机数组
np.random.randint(0,6,3)
生成一个随机数组(二维数组)
np.random.randint(0,6,(3,3))
生成十个随机数在[0,1)之间
np.random.rand(10)
‘‘‘
array([0.9283789 , 0.43515554, 0.27117021, 0.94829333, 0.31733981,
0.42314939, 0.81838647, 0.39091899, 0.33571004, 0.90240897])
‘‘‘
从标准正态分布中随机抽选出3个数
np.random.standard_normal(3)
返回三页四行两列的标准正态分布数
np.random.standard_normal((3,4,2))
x = np.arange(8)
在数组尾部追加一个元素
np.append(x,10)
在数组尾部追加多个元素
np.append(x,[15,16,17])
使用 数组下标修改元素的值
x[0] = 99
在指定位置插入数据
np.insert(x,0,54)
创建一个多维数组
x = np.array([[1,2,3],[11,22,33],[111,222,333]])
修改第 0 行第 2 列的元素值
x[0,2] = 9
行数大于等于 1 的，列数大于等于 1 的置为 1
x[1:,1:] = 1
复制代码
# 同时修改多个元素值
x[1:,1:] = [7,8]
‘‘‘
array([[ 1, 2, 9],
[ 11, 7, 8],
[111, 7, 8]])
‘‘‘
x[1:,1:] = [[7,8],[9,10]]
‘‘‘
array([[ 1, 2, 9],
[ 11, 7, 8],
[111, 9, 10]])
‘‘‘
复制代码
查看数组的大小
n.size
将数组分为两行五列
n.shape = 2,5
显示数组的维度
n.shape
设置数组的维度，-1 表示自动计算
n.shape = 5,-1
将新数组设置为调用数组的两行五列并返回
x = n.reshape(2,5)
复制代码
x = np.arange(5)
# 将数组设置为两行，没有数的设置为 0
x.resize((2,10))
‘‘‘
array([[0, 1, 2, 3, 4, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
‘‘‘
# 将 x 数组的两行五列形式显示，不改变 x 的值
np.resize(x,(2,5))
‘‘‘
array([[0, 1, 2, 3, 4],
[0, 0, 0, 0, 0]])
‘‘‘
复制代码
x = np.array([1,4,5,2])
# array([1, 4, 5, 2])
# 返回排序后元素的原下标
np.argsort(x)
# array([0, 3, 1, 2], dtype=int64)
输出最大值的下标
x.argmax( )
输出最小值的下标
x.argmin( )
对数组进行排序
x.sort( )
每个数组元素对应的正弦值
np.sin(x)
每个数组元素对应的余弦值
np.cos(x)
对参数进行四舍五入
np.round(np.cos(x))
对参数进行上入整数 3.3->4
np.ceil(x/3)
复制代码
# 分段函数
x = np.random.randint(0,10,size=(1,10))
# array([[0, 3, 6, 7, 9, 4, 9, 8, 1, 8]])
# 大于 4 的置为 0
np.where(x > 4,0,1)
# array([[1, 1, 0, 0, 0, 1, 0, 0, 1, 0]])
# 小于 4 的乘 2 ，大于 7 的乘3
np.piecewise(x,[x<4,x>7],[lambda x:x*2,lambda x:x*3])
# array([[ 0, 6, 0, 0, 27, 0, 27, 24, 2, 24]])
导包
import pandas as pd
设置输出结果列对齐
pd.set_option(‘display.unicode.ambiguous_as_wide‘,True)
pd.set_option(‘display.unicode.east_asian_width‘,True)
创建 从 0 开始的非负整数索引
s1 = pd.Series(range(1,20,5))
使用字典创建 Series 字典的键作为索引
s2 = pd.Series({‘语文‘:95,‘数学‘:98,‘Python‘:100,‘物理‘:97,‘化学‘:99})
修改 Series 对象的值
s1[3] = -17
查看 s1 的绝对值
abs(s1)
将 s1 所有的值都加 5、使用加法时，对所有元素都进行
s1 + 5
在 s1 的索引下标前加入参数值
s1.add_prefix(2)
s2 数据的直方图
s2.hist()
每行索引后面加上 hany
s2.add_suffix(‘hany‘)
查看 s2 中最大值的索引
s2.argmax()
查看 s2 的值是否在指定区间内
s2.between(90,100,inclusive = True)
查看 s2 中 97 分以上的数据
s2[s2 > 97]
查看 s2 中大于中值的数据
s2[s2 > s2.median()]
s2 与数字之间的运算,开平方根 * 10 保留一位小数
round((s2**0.5)*10,1)
s2 的中值
s2.median()
s2 中最小的两个数
s2.nsmallest(2)
s2 中最大的两个数
s2.nlargest(2)
Series 对象之间的运算,对相同索引进行计算,不是相同索引的使用 NaN
pd.Series(range(5)) + pd.Series(range(5,10))
对 Series 对象使用匿名函数
pd.Series(range(5)).pipe(lambda x,y,z :(x**y)%z,2,5)
pd.Series(range(5)).pipe(lambda x:x+3)
pd.Series(range(5)).pipe(lambda x:x+3).pipe(lambda x:x*3)
对 Series 对象使用匿名函数
pd.Series(range(5)).apply(lambda x:x+3)
查看标准差
pd.Series(range(0,5)).std()
查看无偏方差
pd.Series(range(0,5)).var()
查看无偏标准差
pd.Series(range(0,5)).sem()
查看是否存在等价于 True 的值
any(pd.Series([3,0,True]))
查看是否所有的值都等价于 True
all(pd.Series([3,0,True]))
创建一个 DataFrame 对象
dataframe = pd.DataFrame(np.random.randint(1,20,(5,3)),
index = range(5),
columns = [‘A‘,‘B‘,‘C‘])
索引为时间序列
dataframe2 = pd.DataFrame(np.random.randint(5,15,(9,3)),
index = pd.date_range(start = ‘202003211126‘,
end = ‘202003212000‘,
freq = ‘H‘),
columns = [‘Pandas‘,‘爬虫‘,‘比赛‘])
使用字典进行创建
dataframe3 = pd.DataFrame({‘语文‘:[87,79,67,92],
‘数学‘:[93,89,80,77],
‘英语‘:[88,95,76,77]},
index = [‘张三‘,‘李四‘,‘王五‘,‘赵六‘])
创建时自动扩充
dataframe4 = pd.DataFrame({‘A‘:range(5,10),‘B‘:3})
查看周几
dff[‘日期‘] = pd.to_datetime(data[‘日期‘]).dt.weekday_name
按照周几进行分组，查看交易的平均值
dff = dff.groupby(‘日期‘).mean().apply(round)
dff.index.name = ‘周几‘
对姓名和日期进行分组,并进行求和
dff = dataframe.groupby(by = [‘姓名‘,‘日期‘],as_index = False).sum()
将 dff 的索引，列 设置成透视表形式
dff = dff.pivot(index = ‘姓名‘,columns = ‘日期‘,values = ‘交易额‘)
查看前一天的数据
dff.iloc[:,:1]
交易总额小于 4000 的人的前三天业绩
dff[dff.sum(axis = 1) < 4000].iloc[:,:3]
工资总额大于 2900 元的员工的姓名
dff[dff.sum(axis = 1) > 2900].index.values
显示前两天每一天的交易总额以及每个人的交易金额
dataframe.pivot_table(values = ‘交易额‘,index = ‘姓名‘,
columns = ‘日期‘,aggfunc = ‘sum‘,margins = True).iloc[:,:2]
显示每个人在每个柜台的交易总额
dff = dataframe.groupby(by = [‘姓名‘,‘柜台‘],as_index = False).sum()
dff.pivot(index = ‘姓名‘,columns = ‘柜台‘,values = ‘交易额‘)
查看每人每天的上班次数
dataframe.pivot_table(values = ‘交易额‘,index = ‘姓名‘,columns = ‘日期‘,aggfunc = ‘count‘,margins = True).iloc[:,:1]
查看每个人每天购买的次数
dataframe.pivot_table(values = ‘交易额‘,index = ‘姓名‘,columns = ‘日期‘,aggfunc = ‘count‘,margins = True)
每个人每天上过几次班
pd.crosstab(dataframe.姓名,dataframe.日期,margins = True).iloc[:,:2]
每个人每天去过几次柜台
pd.crosstab(dataframe.姓名,dataframe.柜台)
将每一个人在每一个柜台的交易总额显示出来
pd.crosstab(dataframe.姓名,dataframe.柜台,dataframe.交易额,aggfunc=‘sum‘)
每个人在每个柜台交易额的平均值,金额/天数
pd.crosstab(dataframe.姓名,dataframe.柜台,dataframe.交易额,aggfunc = ‘mean‘).apply(lambda num:round(num,2) )
对 5 的余数进行分组
dataframe.groupby(by = lambda num:num % 5)[‘交易额‘].sum()
查看索引为 7 15 的交易额
dataframe.groupby(by = {7:‘索引为7的行‘,15:‘索引为15的行‘})[‘交易额‘].sum()
查看不同时段的交易总额
dataframe.groupby(by = ‘时段‘)[‘交易额‘].sum()
各柜台的销售总额
dataframe.groupby(by = ‘柜台‘)[‘交易额‘].sum()
查看每个人在每个时段购买的次数
count = dataframe.groupby(by = ‘姓名‘)[‘时段‘].count()
每个人的交易额平均值并排序
dataframe.groupby(by = ‘姓名‘)[‘交易额‘].mean().round(2).sort_values()
每个人的交易额，apply(int) 转换为整数
dataframe.groupby(by = ‘姓名‘).sum()[‘交易额‘].apply(int)
每一个员工交易额的中值
data = dataframe.groupby(by = ‘姓名‘).median()
查看交易额对应的排名
data[‘排名‘] = data[‘交易额‘].rank(ascending = False)
data[[‘交易额‘,‘排名‘]]
每个人不同时段的交易额
dataframe.groupby(by = [‘姓名‘,‘时段‘])[‘交易额‘].sum()
设置各时段累计
dataframe.groupby(by = [‘姓名‘])[‘时段‘,‘交易额‘].aggregate({‘交易额‘:np.sum,‘时段‘:lambda x:‘各时段累计‘})
对指定列进行聚合,查看最大,最小,和,平均值,中值
dataframe.groupby(by = ‘姓名‘).agg([‘max‘,‘min‘,‘sum‘,‘mean‘,‘median‘])
查看部分聚合后的结果
dataframe.groupby(by = ‘姓名‘).agg([‘max‘,‘min‘,‘sum‘,‘mean‘,‘median‘])[‘交易额‘]
查看交易额低于 2000 的三条数据
dataframe[dataframe.交易额 < 2000][:3]
查看上浮了 50% 之后依旧低于 1500 的交易额,查看 4 条数据
dataframe.loc[dataframe.交易额 < 1500,‘交易额‘] = dataframe[dataframe.交易额 < 1500][‘交易额‘].map(lambda num:num*1.5)
查看交易额大于 2500 的数据
dataframe[dataframe.交易额 > 2500]
查看交易额低于 900 或 高于 1800 的数据
dataframe[(dataframe.交易额 < 900)|(dataframe.交易额 > 1800)]
将所有低于 200 的交易额都替换成 200
dataframe.loc[dataframe.交易额 < 200,‘交易额‘] = 200
查看低于 1500 的交易额个数
dataframe.loc[dataframe.交易额 < 1500,‘交易额‘].count()
将大于 3000 元的都替换为 3000 元
dataframe.loc[dataframe.交易额 > 3000,‘交易额‘] = 3000
查看有多少行数据
len(dataframe)
丢弃缺失值之后的行数
len(dataframe.dropna())
包含缺失值的行
dataframe[dataframe[‘交易额‘].isnull()]
使用固定值替换缺失值
dff = copy.deepcopy(dataframe)
dff.loc[dff.交易额.isnull(),‘交易额‘] = 999
使用交易额的均值替换缺失值
dff = copy.deepcopy(dataframe)
for i in dff[dff.交易额.isnull()].index:
dff.loc[i,‘交易额‘] = round(dff.loc[dff.姓名 == dff.loc[i,‘姓名‘],‘交易额‘].mean())
使用整体均值的 80% 填充缺失值
dataframe.fillna({‘交易额‘:round(dataframe[‘交易额‘].mean() * 0.8)},inplace = True)
查看重复值
dataframe[dataframe.duplicated()]
丢弃重复行
dataframe = dataframe.drop_duplicates()
查看员工业绩波动情况(每一天和昨天的数据作比较)
dff = dataframe.groupby(by = ‘日期‘).sum()[‘交易额‘].diff()
对数据使用 map 函数
dff.map(lambda num:‘%.2f‘%(num))[:5]
查看张三的波动情况
dataframe[dataframe.姓名 == ‘张三‘].groupby(by = ‘日期‘).sum()[‘交易额‘].diff()
修改异常值
data.loc[data.交易额 > 3000,‘交易额‘] = 3000
data.loc[data.交易额 < 200,‘交易额‘] = 200
删除重复值
data.drop_duplicates(inplace = True)
填充缺失值
data[‘交易额‘].fillna(data[‘交易额‘].mean(),inplace = True)
使用交叉表得到每人在各柜台交易额的平均值
data_group = pd.crosstab(data.姓名,data.柜台,data.交易额,aggfunc = ‘mean‘).apply(round)
绘制柱状图
data_group.plot(kind = ‘bar‘)
使用 concat 连接两个相同结构的 DataFrame 对象
df3 = pd.concat([df1,df2])
合并，忽略原来的索引 ignore_index
df4 = df3.append([df1,df2],ignore_index = True)
按照列进行拆分
df5 = df4.loc[:,[‘姓名‘,‘柜台‘,‘交易额‘]]
按照工号进行合并，随机查看 3 条数据
rows = np.random.randint(0,len(df5),3)
pd.merge(df4,df5).iloc[rows,:]
按照工号进行合并，指定其他同名列的后缀
pd.merge(df1,df2,on = ‘工号‘,suffixes = [‘_x‘,‘_y‘]).iloc[:,:]
两个表都设置工号为索引 set_index
df2.set_index(‘工号‘).join(df3.set_index(‘工号‘),lsuffix = ‘_x‘,rsuffix = ‘_y‘).iloc[:]
按照交易额和工号降序排序，查看五条数据
dataframe.sort_values(by = [‘交易额‘,‘工号‘],ascending = False)[:5]
按照交易额和工号升序排序，查看五条数据
dataframe.sort_values(by = [‘交易额‘,‘工号‘])[:5]
按照交易额降序和工号升序排序，查看五条数据
dataframe.sort_values(by = [‘交易额‘,‘工号‘],ascending = [False,True])[:5]
按工号升序排序
dataframe.sort_values(by = [‘工号‘])[:5]
按列名升序排序
dataframe.sort_index(axis = 1)[:5]
每隔五天--5D
pd.date_range(start = ‘20200101‘,end = ‘20200131‘,freq = ‘5D‘)
每隔一周--W
pd.date_range(start = ‘20200301‘,end = ‘20200331‘,freq = ‘W‘)
间隔两天,五个数据
pd.date_range(start = ‘20200301‘,periods = 5,freq = ‘2D‘)
间隔三小时，八个数据
pd.date_range(start = ‘20200301‘,periods = 8,freq = ‘3H‘)
三点开始，十二个数据，间隔一分钟
pd.date_range(start = ‘202003010300‘,periods = 12,freq = ‘T‘)
每个月的最后一天
pd.date_range(start = ‘20190101‘,end = ‘20191231‘,freq = ‘M‘)
间隔一年，六个数据，年末最后一天
pd.date_range(start = ‘20190101‘,periods = 6,freq = ‘A‘)
间隔一年，六个数据，年初最后一天
pd.date_range(start = ‘20200101‘,periods = 6,freq = ‘AS‘)
使用 Series 对象包含时间序列对象,使用特定索引
data = pd.Series(index = pd.date_range(start = ‘20200321‘,periods = 24,freq = ‘H‘),data = range(24))
三分钟重采样，计算均值
data.resample(‘3H‘).mean()
五分钟重采样，求和
data.resample(‘5H‘).sum()
计算OHLC open,high,low,close
data.resample(‘5H‘).ohlc()
将日期替换为第二天
data.index = data.index + pd.Timedelta(‘1D‘)
查看指定日期的年份是否是闰年
pd.Timestamp(‘20200301‘).is_leap_year
查看指定日期所在的季度和月份
day = pd.Timestamp(‘20200321‘)
查看日期的季度
day.quarter
查看日期所在的月份
day.month
转换为 python 的日期时间对象
day.to_pydatetime()
查看所有的交易额信息
dataframe[‘交易额‘].describe()
查看四分位数
dataframe[‘交易额‘].quantile([0,0.25,0.5,0.75,1.0])
查看最大的交易额数据
dataframe.nlargest(2,‘交易额‘)
查看最后一个日期
dataframe[‘日期‘].max()
查看最小的工号
dataframe[‘工号‘].min()
第一个最小交易额的行下标
index = dataframe[‘交易额‘].idxmin()
第一个最小交易额
dataframe.loc[index,‘交易额‘]
最大交易额的行下标
index = dataframe[‘交易额‘].idxmax()
跳过 1 2 4 行，以第一列姓名为索引
dataframe2 = pd.read_excel(‘超市营业额.xlsx‘,
skiprows = [1,2,4],
index_col = 1)
查看 5 到 10 的数据
dataframe[5:11]
查看第六行的数据
dataframe.iloc[5]
查看第 1 3 4 行的数据
dataframe.iloc[[0,2,3],:]
查看第 1 3 4 行的第 1 2 列
dataframe.iloc[[0,2,3],[0,1]]
查看前五行指定，姓名、时段和交易额的数据
dataframe[[‘姓名‘,‘时段‘,‘交易额‘]][:5]
查看第 2 4 5 行 姓名，交易额 数据 loc 函数
dataframe.loc[[1,3,4],[‘姓名‘,‘交易额‘]]
查看第四行的姓名数据
dataframe.at[3,‘姓名‘]
某一时段的交易总和
dataframe[dataframe[‘时段‘] == ‘14:00-21:00‘][‘交易额‘].sum()
查看张三总共的交易额
dataframe[dataframe[‘姓名‘].isin([‘张三‘])][‘交易额‘].sum()
查看日用品的销售总额
dataframe[dataframe[‘柜台‘] == ‘日用品‘][‘交易额‘].sum()
查看交易额在 1500~3000 之间的记录
dataframe[dataframe[‘交易额‘].between(1500,3000)]
将日期设置为 python 中的日期类型
data.日期 = pd.to_datetime(data.日期)
每七天营业的总额
data.resample(‘7D‘,on = ‘日期‘).sum()[‘交易额‘]
每七天营业总额
data.resample(‘7D‘,on = ‘日期‘,label = ‘right‘).sum()[‘交易额‘]
每七天营业额的平均值
func = lambda item:round(np.sum(item)/len(item),2)
data.resample(‘7D‘,on = ‘日期‘,label = ‘right‘).apply(func)[‘交易额‘]
每七天营业额的平均值
func = lambda num:round(num,2)
data.resample(‘7D‘,on = ‘日期‘,label = ‘right‘).mean().apply(func)[‘交易额‘]
删除工号这一列
data.drop(‘工号‘,axis = 1,inplace = True)
按照姓名和柜台进行分组汇总
data = data.groupby(by = [‘姓名‘,‘柜台‘]).sum()
查看张三的汇总数据
data.loc[‘张三‘,:]
查看张三在蔬菜水果的交易数据
data.loc[‘张三‘,‘蔬菜水果‘]
丢弃工号列
data.drop(‘工号‘,axis = 1,inplace = True)
按照柜台进行排序
dff = data.sort_index(level = ‘柜台‘,axis = 0)
按照姓名进行排序
dff = data.sort_index(level = ‘姓名‘,axis = 0)
按照柜台进行分组求和
dff = data.groupby(level = ‘柜台‘).sum()[‘交易额‘]
平均值
data.mean()
标准差
data.std()
协方差
data.cov()
删除缺失值和重复值,inplace = True 直接丢弃
data.dropna(inplace = True)
data.drop_duplicates(inplace = True)
将 NaN 替换成某一数值
使用 fillna
dataframe.fillna(value = ‘xxx‘,inplace=True)
删除某一个值
使用 drop
dataframe.drop(10,inplace=True)
复制代码
复制代码
交换两行的值
if m != n:
temp = np.copy(dataframe[m])
dataframe[m] = dataframe[n]
dataframe[n] = temp
else:
temp = np.copy(dataframe[dataframe.shape[1]-1])
dataframe[dataframe.shape[1]-1] = dataframe[n]
dataframe[n] = temp
复制代码
删除 columns 这些列
dataframe.drop(columns = list, inplace=True)
2020-07-03
以上是关于关于这学期的总结的主要内容，如果未能解决你的问题，请参考以下文章