标签：xlsx csv文件 循环 transform googl f11 out abs 排序
# 例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中的所有保留字为：\n‘,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(‘数据类型分别为：\n‘, 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 (‘\note\mybook‘) # str中包含\n，识别为换行符并转义
print (‘\title\mybook‘) # str中包含\t，识别为制表符并转义
print (r‘\note\mybook ‘) # 使用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‘), ‘\n‘, ‘list3中a首次出现的位置：‘, list3.index(‘a‘))
list3.insert(0,‘g‘)
list1.append(‘新增‘)
list2.extend(list3)
print(‘在列表指定位置插入元素：‘, list3, ‘\n‘, ‘在列表末尾新增元素：‘, list1, ‘\n‘, ‘将list3扩展至list2：‘, list2)
list3.insert(0,‘g‘)
list1.append(‘新增‘)
list2.extend(list3)
print(‘在列表指定位置插入元素：‘, list3, ‘\n‘, ‘在列表末尾新增元素：‘, list1, ‘\n‘, ‘将list3扩展至list2：‘, list2)
list3.pop(0)
list1.remove(‘新增‘)
print(‘使用pop删除指定位置的元素：‘, list3, ‘\n‘, ‘使用remove删除指定元素：‘, list1)
list2.pop(0)
list2.sort()
list3.reverse()
print(‘列表排序：‘, list2, ‘\n‘, ‘列表反向排序：‘, list3)
# 例1-29 创建tuple
# 使用圆括号创建tuple
tup1 = (‘Google‘, ‘Runoob‘)
print(‘查看tup1类型：‘, type(tup1), ‘\n‘, ‘查看tup1：‘, tup1)
# 不加括号创建tuple
tup2 = "a", "b", "c", "d"
print(‘查看tup2：‘, tup2, ‘\n‘, ‘查看tup2类型：‘, type(tup2))
# 将[‘x‘,’y‘,’z‘]转换成tuple
tup3 = tuple([‘x‘,‘y‘,‘z‘])
print(‘查看tup3：‘, tup3, ‘\n‘, ‘查看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(), ‘\n‘,
‘输出dict1中所有的键：‘, dict1.keys(), ‘\n‘,
‘输出dict1中所有的值：‘, dict1.values())
print(‘与one对应的元素为：‘, dict1.get(‘one‘), dict1.setdefault(‘one‘))
dict1.update(dict2)
dict3 = dict2.copy()
print(‘将dict2中键值对更新到dict1中：‘, dict1, ‘\n‘,
‘将dict2中内容复制到新的字典中：‘, dict3)
dict1.pop(‘name‘)
dict2.popitem()
dict3.clear()
print(‘删除dict1中name键对应的内容：‘, dict1, ‘\n‘,
‘随机删除dict2中的一个键值对为：‘, dict2.popitem(), ‘\n‘,
‘清空dict3中的内容：‘, dict3)
# 例1-35 创建 set
# 使用非空的{}创建set
set1 = {1, 2, 3}
print(‘set1的类型为：‘, type(set1))
# 创建一个空的set只能使用set函数
set2 = set()
print(‘查看set2：‘, set2, ‘\n‘, ‘set2的类型为：‘, type(set2))
# 将list、tuple转换为set
set3 = set([1,2,3])
set4 = set((1,2,3))
print(‘查看set3和set4：‘, set3, set4, ‘\n‘,
‘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的类型分别为：\n‘,
# 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(‘\nkey_value：‘, end = ‘‘)
for key, value in dic.items():
print(key, value, sep = ‘:‘, end = ‘ ‘)
# 遍历键
print(‘\nkeys：‘, end = ‘‘)
for key in dic.keys():
print(key, end = ‘ ‘)
# 遍历值
print(‘\nvalues：‘, 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), ‘\n‘,
‘list1的可变字节数组为：‘, bytearray(list1))
# chr函数、ord函数
print(‘整数40的unicode字符为：‘, chr(40), ‘\n‘,
‘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), ‘\n‘,
‘序列中的最小数为：‘, 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, ‘\n‘, ‘返回为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, ‘\n‘,
‘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为：\n‘, 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为：\n‘,np.linspace(0, 1, 12))
print(‘使用logspace函数创建的ndarray为：\n‘, np.logspace(0, 2, 20))
print(‘使用zeros函数创建的ndarray为：\n‘, np.zeros((2, 3)))
print(‘使用eye函数创建的ndarray为：\n ‘, np.eye(3))
print(‘使用diag函数创建的ndarray为：\n‘,np.diag([1, 2, 3, 4]))
print(‘使用ones函数的ndarray为：\n‘, np.ones((2, 3)))
# 代码 3-4
print(‘random函数生成的随机数ndarray为：\n‘, np.random.random(100))
print(‘rand函数生成的服从均匀分布的随机数ndarray为：\n‘, np.random.rand(4, 5))
print(‘randn函数生成的服从正态分布的随机数ndarray为：\n‘, np.random.randn(4, 5))
print(‘randint函数生成的指定上下限的随机整数ndarray为：\n‘,
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为：\n‘, arr)
print(‘切片结果为：‘, arr[0, 3:5]) # 访问第0行中第3和第4列的元素
print(‘切片结果为：\n‘, arr[1:, 2:]) # 访问第1和第2行中第2列、第3列和第4列的元素
print(‘切片结果为：\n‘, 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为：\n‘, arr)
print(‘以特定顺序索引arr结果为：\n‘, arr[[4, 3, 0, 6]])
print(‘以特定逆序索引arr结果为：\n‘, arr[[-3, -5, -7]])
arr = np.array([np.arange(i*4, i*4+4) for i in np.arange(6)])
print(‘创建的二维ndarray arr为：\n‘, 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为：\n‘, arr1)
print(‘形状改变后ndarray arr1的维度为：‘, arr1.ndim)
# 代码 3-7
arr.resize(2, 6)
print(‘resize改变原ndarray形状，ndarray arr变为：\n‘, arr)
arr.shape = (4, 3)
print(‘通过重新设置shape属性后，ndarray arr为：\n‘, arr)
# 代码 3-8
arr = np.arange(12).reshape(3, 4)
print(‘创建的二维ndarray arr为：\n‘, 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为：\n‘, arr1)
arr2 = arr1*3
print(‘创建的ndarray arr2为：\n‘, arr2)
print(‘hstack横向组合ndarray arr1与arr2为：\n‘, np.hstack((arr1, arr2)))
print(‘vstack纵向组合ndarray arr1与arr2为：\n‘, np.vstack((arr1, arr2)))
# 代码 3-9
print(‘concatenate横向组合arr1与arr2为：\n‘, np.concatenate((arr1, arr2), axis=1))
print(‘concatenate纵向组合arr1与arr2为：\n‘, np.concatenate((arr1, arr2), axis=0))
print(‘dstack深度组合arr1与arr2为：\n‘, np.dstack((arr1, arr2)))
# 代码 3-10
arr = np.arange(16).reshape(4, 4)
print(‘创建的二维ndarray arr为：\n‘, arr)
print(‘hsplit横向分割arr为：\n‘, np.hsplit(arr, 2))
print(‘hsplit纵向分割arr为：\n‘, np.vsplit(arr, 2))
print(‘split横向分割arr为：\n‘, np.split(arr, 2, axis=1))
print(‘split纵向分割arr为：\n‘, 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为：\n‘, arr)
print(‘默认排序后ndarray arr为：\n‘, np.sort(arr))
print(‘展平排序的ndarray arr为：‘, np.sort(arr, axis=None))
# 代码 3-11
print(‘横轴排序后ndarray arr为：\n‘, np.sort(arr, axis=1))
print(‘纵轴排序后ndarray arr为：\n‘, np.sort(arr, axis=0))
print(‘横轴排序后arr的下标为：\n‘, 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为：\n‘, 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为：\n‘, arr)
print(‘where输出ndarray arr满足条件的下标为：\n‘, np.where(arr>6))
arr1 = np.arange(12).reshape(3, 4)
print(‘创建的ndarray arr1为：\n‘, arr1)
arr2 = np.arange(-12, 0).reshape(3, 4)
print(‘创建的ndarray arr2为：\n‘, arr2)
exp = arr1>5
print(‘arr1大于5的布尔ndarray为：\n‘, exp)
# 代码 3-13
print(‘where函数搜索符合条件的arr1与arr2为：\n‘, np.where(exp, arr1, arr2))
arr = np.arange(9).reshape(3, 3)
print(‘创建的ndarray arr为：\n‘, arr)
exp = (arr % 2) == 0
print(‘arr能被2整除的布尔ndarray为：\n‘, exp)
print(‘arr基于条件exp提取的元素为：\n‘, 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为：\n‘, arr)
print(‘ndarray arr各元素的相反数为：\n‘, np.negative(arr))
print(‘ndarray arr各元素的绝对值为：\n‘, np.absolute(arr))
print(‘ndarray arr各元素的符号为：\n‘, np.sign(arr))
print(‘ndarray arr各元素的平方根为：\n‘, np.sqrt(arr))
print(‘ndarray arr各元素的自然对数为：\n‘, np.log(arr))
# 代码 3-16
arr = np.arange(20).reshape(4, 5)
print(‘创建的ndarray arr为：\n‘, 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的元素累计积为：\n‘, np.cumprod(arr))
# # 代码 3-18
# import numpy as np
# arr = np.load(‘../data/arr.npy‘)
# print(‘从二进制文件arr.npy读取的ndarray arr为：\n‘, arr)
# arr1 = np.load(‘../data/arr.npz‘)
# print(‘从二进制文件arr.npz读取的第1个ndarray为：\n‘, arr1[‘arr_0‘])
# print(‘从二进制文件arr.npz读取的第2个ndarray为：\n‘, arr1[‘arr_1‘])
# # 代码 3-19
# np.random.seed(123)
# arr = np.random.rand(25).reshape(5, 5)
# print(‘创建的ndarray arr为：\n‘, arr)
# np.save(‘../tmp/save_arr.npy‘, arr)
# print(‘……存储成功……‘)
# # 代码 3-20
# arr1 = np.random.rand(36).reshape(6, 6)
# print(‘创建的ndarray arr1为：\n‘, arr1)
# arr2 = np.random.rand(16).reshape(4, 4)
# print(‘创建的ndarray arr2为：\n‘, arr2)
# np.savez(‘../tmp/save_arr.npz‘, arr1, arr2)
# # 代码 3-20
# arr3 = np.load(‘../tmp/save_arr.npz‘)
# print(‘存取的第1个ndarray为：\n‘, arr3[‘arr_0‘])
# np.savez(‘../tmp/save_kwds.npz‘, x=arr1, y=arr2)
# arr4 = np.load(‘../tmp/save_kwds.npz‘)
# print(‘存取的第2个ndarray为：\n‘, arr4[‘y‘])
# # 代码 3-21
# # 指定分隔符读入文本文件
# arr = np.loadtxt("../data/arr.txt", delimiter=",")
# print(‘读取的ndarray arr为：\n‘, 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为：\n‘, bool)
print(‘通过bool数据访问Series结果为：\n‘, series[bool])
# 代码 3-24
# 更新元素
series[‘a‘] = 3
print(‘更新后的Series为：\n‘, series)
series1 = pd.Series([4, 5], index = [‘f‘, ‘g‘])
# 追加Series
print(‘在series插入series1后为：\n‘, series.append(series1))
# 新增单个数据
series1[‘h‘] = 7
print(‘在series1插入单个数据后为：\n‘, series1)
# 删除数据
series.drop(‘e‘, inplace = True)
print(‘删除索引e对应数据后的series为：\n‘, series)
# 代码 3-25
dict1 = {‘col1‘: [0, 1, 2, 3, 4], ‘col2‘: [5, 6, 7, 8, 9]}
print(‘通过dict创建的DataFrame为：\n‘, pd.DataFrame(dict1, index = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]))
list2 = [[0, 5], [1, 6], [2, 7], [3, 8], [4, 9]]
print(‘通过list创建的DataFrame为：\n‘,
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为：\n‘, df)
# 插入列
df[‘col3‘] = [15, 16, 17, 18, 19]
print(‘插入列后的DataFrame为：\n‘, df)
# 代码 3-28
# 删除列
df.drop([‘col3‘], axis = 1, inplace = True)
print(‘删除col3列后的DataFrame为：\n‘, df)
# 删除行
df.drop(‘a‘, axis = 0, inplace = True)
print(‘删除a行后的DataFrame为：\n‘, 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为：\n‘, df)
# 访问单列数据
print(‘DataFrame中col1列数据为：\n‘, df[‘col1‘])
# 以属性的方式访问单列数据
print(‘DataFrame中col1列数据为：\n‘, df.col1)
# 代码3-30
# 访问单列多行数据
print(‘DataFrame中col1列前3行数据为：\n‘, df[‘col1‘][0: 3])
# 访问多列多行数据
print(‘DataFrame中col1列、col2列前3行数据为：\n‘, df[[‘col1‘, ‘col2‘]][0: 3])
# 访问多行数据
print(‘DataFrame的前3行为：\n‘, df[: ][0: 3])
# 代码 3-31
# 访问单列数据
print(‘DataFrame中col1列数据为：\n‘, df.loc[: , ‘col1‘])
# 访问多列数据
print(‘DataFrame中col1列、col2数据为：\n‘, df.loc[: , [‘col1‘, ‘col2‘]])
# 访问单行数据
print(‘DataFrame中a行对应数据为：\n‘, df.loc[‘a‘, :])
# 访问多行数据
print(‘DataFrame中a行、b行对应数据为：\n‘, df.loc[[‘a‘, ‘b‘], :])
# 行列结合访问数据
print(‘DataFrame中a行、b行，col1列、col2列对应的数据为：\n‘,
df.loc[[‘a‘, ‘b‘], [‘col1‘, ‘col2‘]])
# 接收bool数据
print(‘DataFrame中col1列大于0的数据为：\n‘, df.loc[df[‘col1‘] > 0, :])
# 接收函数
print(‘DataFrame中col1列大于0的数据为：\n‘, df.loc[lambda df: df[‘col1‘] > 0, :])
# 代码 3-32
# 访问单列数据
print(‘DataFrame中col1列数据为：\n‘, df.iloc[: , 0])
# 访问多列数据
print(‘DataFrame中col1列、col2列数据为：\n‘, df.iloc[: , [0, 1]])
# 访问单行数据
print(‘DataFrame中a行数据为：\n‘, df.iloc[0, :])
# 访问多行数据
print(‘DataFrame中a行、b行数据为：\n‘, df.iloc[[0, 1], :])
# 行列结合访问数据
print(‘DataFrame中a行、b行，col1列、col2列数据为：\n‘, 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为:\n‘, df1)
print(‘DataFrame的层次化索引为:\n‘, df1.index)
# 代码 3-34
print(‘访问DataFrame第1索引层bar，第2索引层two结果为：\n‘,
df1.loc[(‘bar‘, ‘two‘), :])
print(‘访问DataFrame第1索引层bar、baz、foo，第2索引层one、two结果为：\n‘,
df1.loc[([‘bar‘, ‘baz‘, ‘foo‘], [‘one‘, ‘two‘]), :])
print(‘访问DataFrame第1索引层bar、baz、foo，第2索引层one、two结果为：\n‘,
df1.loc[(slice(‘bar‘, ‘foo‘), slice(None)), :])
# 代码 3-35
# 接收单个标签
idx = pd.IndexSlice
print(‘访问DataFrame第1索引层bar，第2索引层two结果为：\n‘, df1.loc[idx[‘bar‘, ‘two‘], :])
# 接收标签list
print(‘访问DataFrame第1索引层bar、foo，第2索引层two结果为：\n‘,
df1.loc[idx[[‘bar‘, ‘foo‘], ‘two‘], :])
# 接收标签切片
print(‘访问DataFrame第1索引层bar到foo，第2索引层two结果为：\n‘,
df1.loc[idx[‘bar‘: ‘foo‘, ‘one‘], :])
# 接收bool数组
con = df1[‘column1‘]>0
print(‘访问DataFrame第1索引层bar到foo，第二索引层对应的‘
‘column1列大于0结果为：\n‘,df1.loc[idx[‘bar‘: ‘foo‘, con], :])
# 代码 3-36
# 按行索引排序
print(‘按行索引排序后的DataFrame为：\n‘, df.sort_index(axis = 0))
# 按列索引降序排列
print(‘按列索引降序排列后的DataFrame为：\n‘, df.sort_index(axis = 1, ascending = False))
# 按列排序
print(‘按col2列排序后的DataFrame为：\n‘, df.sort_values(‘col2‘))
# 按行降序排列
print(‘按列降序排列后的DataFrame为：\n‘, df.sort_values(‘a‘, axis = 1, ascending = False))
print(‘按col2列排序,返回前2个最小值：\n‘, df.nsmallest(2, ‘col2‘))
print(‘按col2列排序,返回前2个最大值：\n‘, 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为：\n‘, pd.concat([df2, df3], axis = 1))
# 横向堆叠（内连）df2、df3
print(‘横向堆叠（内连）df2、df3后的DataFrame为：\n‘,
pd.concat([df2, df3], axis = 1, join = ‘inner‘))
# 代码 3-38
print(‘横向堆叠df2、df3后的DataFrame为：\n‘, df2.join(df3, rsuffix = ‘_2‘))
# 纵向堆叠df2、df3
print(‘纵向堆叠df2、df3后的DataFrame为：\n‘, pd.concat([df2, df3], axis = 0))
# 纵向堆叠（内连）df2、df3
print(‘纵向堆叠（内连）df2、df3后的DataFrame为：\n‘,
pd.concat([df2, df3], axis = 0, join = ‘inner‘))
print(‘纵向堆叠df2、df3后的DataFrame为：\n‘, df2.append(df3))
# 代码 3-39
print(‘以列key为键，内连df2、df3后的DataFrame为：\n‘,
pd.merge(df2, df3, on = ‘key‘, how = ‘inner‘))
# # 代码 3-40
# df = pd.read_csv(‘../data/meal_order_info.csv‘, encoding = ‘gbk‘)
# print(‘读取的CSV文件前5行数据为：\n‘, df.head())
# # 代码 3-42
# df = pd.read_excel(‘../data/users_info.xlsx‘, encoding = ‘gbk‘)
# print(‘读取的Excel文件前5行数据为：\n‘, 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-master\iris.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每列对应的最大值为：\n‘, np.max(df), ‘\n‘, ‘数据框df每列对应的最小值为：\n‘, np.min(df))
# print(‘数据框df每列对应的均值为：\n‘, np.mean(df))
# print(‘数据框df对应的中位数为：‘, np.median(df))
# print(‘数据框df每列对应的标准差为：\n‘, np.std(df))
# print(‘数据框df每列对应的方差为：\n‘, np.var(df))
# # 代码 4-18
# print(‘数据框df每列对应的最大值为：\n‘, df.max(), ‘\n‘,‘数据框df每列对应的最小值为：\n‘, df.min())
# print(‘数据框df每列对应的均值为：\n‘, df.mean())
# print(‘数据框df每列对应的中位数为：\n‘, df.median())
# print(‘数据框df每列对应的标准差为：\n‘, df.std())
# print(‘数据框df每列对应的方差为：\n‘, df.var())
# print(‘使用describe方法的描述性统计结果为：\n‘, df.describe())
# # 代码 4-19
# df1 = pd.DataFrame({‘col1‘: list(‘abca‘), ‘col2‘: list(‘bccd‘)}, dtype = ‘category‘)
# print(‘使用describe方法的描述性统计结果为：\n‘, df1.describe())
# print(‘DataFrame的info信息为：\n‘)
# df.info()
# # 代码 4-20
# station = pd.read_csv(‘D:/data/Station.csv‘, encoding = ‘gbk‘)
# group = station.groupby(‘station‘)
# print(‘以station为分组键，创建的GroupBy对象为：\n‘, group)
# print(‘分组数据的均值前5行结果为：\n‘, group.mean().head())
# print(‘分组数据的和前5行结果为：\n‘,group.sum().head())
# print(‘分组数据的最大值前5行结果为：\n‘,group.max().head())
# # 代码 4-21
# print(‘分组的均值前5行结果为：\n‘, group.agg(np.mean).head())
# def f(x):
# return x.max() - x.min()
# group1 = group.agg(f)
# print(‘分组的极差前5行结果为：\n‘, group1.head())
# group2 = group.agg([np.mean, np.sum])
# print(‘分组的均值和总和前5行结果为：\n‘, group2.head())
# group3 = group.agg({‘on_man‘: np.mean, ‘off_man‘: np.sum})
# print(‘列on_man应用均值函数，列off_man应用汇总函数前5行结果为：\n‘, group3.head())
# # 代码 4-22
# print(‘分组的均值前5行结果为：\n‘, group.apply(np.mean).head())
# def f(x):
# result = x[0: 2]
# return result
# print(‘分组的前两个数据前5行结果为：\n‘, group.apply(f).head())
# # 代码 4-23
# print(‘对分组应用均值函数，返回的DataFrame前5行数据为：\n‘,
# group.transform(np.mean).head())
# def f(x):
# result = x*2
# return result
# print(‘对分组的每个元组乘以2，返回的DataFrame前5行数据为：\n‘, 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(‘创建的透视表为：\n‘, tdf)
tdf = pd.pivot_table(df, index=[‘four‘], columns=[‘one‘], aggfunc = np.sum)
print(‘分组和的透视表为：\n‘, tdf)
# 代码 4-25
cdf = pd.crosstab(index = df[‘four‘], columns = df[‘one‘])
print(‘创建的交叉表为：\n‘, cdf)
cdf = pd.pivot_table(df, values = ‘two‘, index = [‘four‘], columns = [‘one‘],
aggfunc = (lambda x: len(x)))
print(‘使用pivot_table函数创建的交叉表为：\n‘, 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
标签：xlsx csv文件 循环 transform googl f11 out abs 排序
原文地址：https://www.cnblogs.com/hany-postq473111315/p/13228741.html
