码迷,mamicode.com
首页 > 其他好文 > 详细

关于这学期的总结

时间:2020-07-03 10:41:24      阅读:220      评论:0      收藏:0      [点我收藏+]

标签: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(rE:\资料\数据集\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

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!