[开发工具]jupyter第二章例题与实训展示

例2-1

In?[1]:

answer = int (input("请输入一个数:"))

if answer == 2:

    print("hello,")

    print("it's True")

else:

    print("sorry,")

    print("it's Flase")

请输入一个数:2
hello,
it's True

例2-2

In?[2]:

brower,count,addsum = 'Google',100,123.45

print(brower,count,addsum)

Google 100 123.45

例2-3

In?[3]:

print("python\nprogram")

print(r"python\nprogram")

python
program
python\nprogram

例2-4

In?[4]:

score = float(input("请输入成绩"))

if score>=60:

    print("合格")

else:

    print("不合格")

请输入成绩78
合格

例2-5

In?[5]:

compound = input("请输入化学公式：")

if compound =="H20":

    print("water")

elif compound =="NH3":

    print("ammonia")

elif compound =="CH3":

    print("methane")

else:

    print("no exist")

请输入化学公式：NH3
ammonia

例2-6

In?[6]:

sum = 0

i=1

while i<6:

    sum+=i

    i+=1

print("sum is %d." %sum)

sum is 15.

例2-7

In?[9]:

i=1

while i<20:

    if i % 3 == 0:

        print(i,end = '  ')

    i = i+1

3  6  9  12  15  18  

例2-8

range() 函数可创建一个整数列表，一般用在 for 循环中

range(start, stop[, step])

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)?

range（）是依次取顺序的数值，常与for循环一起用。

list（）是把字符串转换为列表

1. 列表的常用方法

1）L.append(v) ：把元素v添加到列表L的结尾，相当于a[len(a)] = [v]

2）L.insert(i,v)：将值v插入到列表L的索引i处

3）L.index(x)：返回列表中第一个值为x的元素的索引

4）L.remove(v)：从列表L中移除第一次找到的值v

5）L.pop([i])：从列表的指定位置删除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。

6）L.reverse()：倒排列表中的元素

7）L.count(x)：返回x在列表中出现的次数

8）L.sort(key=None, reverse=False)：对链表中的元素进行适当的排序。

In?[10]:

sum=0

for i in range(1,6):

    sum = sum + i

print("1+2+3+4+5 = %d." %sum)

1+2+3+4+5 = 15.

例2-9

In?[11]:

x = [1,2,3,4,8,7,22,33,88]

print("原数据：",x)

for i in range(len(x)):

    if(x[i] % 2)!= 0:

        x[i] = x[i]*x[i]

print("处理后：",x)    

原数据： [1, 2, 3, 4, 8, 7, 22, 33, 88]
处理后： [1, 2, 9, 4, 8, 49, 22, 1089, 88]
len() 函数返回对象中项目的数量。

当对象是字符串时，len(object) 函数返回字符串中的字符数。

object是必需的对象。必须是序列或集合

例2-10——例2-17

In?[12]:

list = ['a','b','c','d']

list.insert(1,'Baidu')

print("更新后的列表：",list)

更新后的列表： ['a', 'Baidu', 'b', 'c', 'd']

In?[13]:

list =['a','b','c','d']

print('b索引值为',list.index('b'))

b索引值为 1

In?[14]:

list =['a','b','c','d']

list.remove('d')

list

Out[14]:

['a', 'b', 'c']

remove(obj) 函数用于移除列表中某个值的第一个匹配项

obj -- 列表中要移除的对象

该方法没有返回值但是会移除列表中的某个值的第一个匹配项

In?[15]:

list =['a','b','c','d']

p = list.pop()

print("删除 %r后的列表为 %r:" %(p,list))

print("删除元素为：",list.pop(1))

删除 'd'后的列表为 ['a', 'b', 'c']:
删除元素为： b

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

list.pop([index=-1])

obj -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

该方法返回从列表中移除的元素对象。

In?[16]:

list =['a','b','c','d']

list.reverse()

list

Out[16]:

['d', 'c', 'b', 'a']

reverse() 函数用于反向列表中元素。

list.reverse(NA)

该方法没有返回值，但是会对列表的元素进行反向排序

In?[17]:

list =['a','b','c','d','a','b','c','a','c']

print("c出现的次数是：",list.count('c'))

print("list中一共有%d个a." % list.count('a'))

c出现的次数是： 3
list中一共有3个a.

In?[18]:

list =['a','b','c','d']

list.sort(reverse = True)

list

Out[18]:

['d', 'c', 'b', 'a']

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

list.sort(cmp=None, key=None, reverse=False)

cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

该方法没有返回值，但是会对列表的对象进行排序。

例2-18

In?[3]:

vec =[2,4,6,8,10]

print([3 * x for x in vec])

print([3 * x for x in vec if x>6])

vec1 = [2,4,6]

vec2 = [4,3,-9]

print ([x * y for x in vec1 for y in vec2 if x * y > 0])

[6, 12, 18, 24, 30]
[24, 30]
[8, 6, 16, 12, 24, 18]

1.带有if的条件

for 语句后面跟上一个 if 判断语句，用于过滤掉那些不满足条件的结果项

2.带有for的嵌套

在复杂一点的列表推导式中，可以嵌套有多个 for 语句。按照从左至右的顺序，分别是外层循环到内层循环。

3.既有 if 语句又有 for 嵌套

列表推导式可以带任意数量的嵌套 for 循环，并且每一个 for 循环后面都有可选的 if 语句。

通用语法：

[ expression for x in X [if condition]

 ? ? ? ? ? ? for y in Y [if condition]

 ? ? ? ? ? ? ...

 ? ? ? ? ? ? for n in N [if condition] ] ? ? ? ? 

4. 列表推导式生成矩阵

生成矩阵的方式有多种，如手动赋值、一般 for 循环，还有就是列表推导式.

我们要用列表推导式生成下面的矩阵

>>> M = [[1, 2, 3],

... [4, 5, 6],

... [7, 8, 9]]

一种方法是：

>>> M = [[x, x+1, x+2] for x in [1, 4, 7]]

>>> M

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

矩阵的列数少时可以使用这种方法。

如果矩阵的列数较多，我们可以使用另外一种方式：在循环变量的表达式中使用列表推导式。例如：

>>> M = [[y for y in range(x, x+3)] for x in [1, 4, 7]]

>>> M

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

?

与之前带 for 嵌套的语法不同，这个例子中，实际使用的是最基本[expression for x in L] 语法，只有一个 for 语句。

复杂的地方在于前面的变量表达式 expression 不再是简单的变量运算，而是一个列表推导式，在这个例子中就是 [y for y in range(x, x+3)] 。

例2-19

In?[1]:

import random

total = []#空表

for i in range(30):    

    total.append(random.randint(1,150))#追加 生成的随机整数

print(total)#输出列表

sum = 0 

for item in total:    

    sum = sum + item

print(sum)#求和

total_m = sum // len(total)

print(total_m)

print([x - total_m for x in total])

#随机生成30个数，构成列表，输出列表的和与平均值，最后每一个随机数减去均值构成新的列表

[8, 119, 42, 30, 147, 136, 62, 72, 134, 80, 44, 115, 140, 82, 125, 36, 80, 90, 130, 142, 129, 71, 37, 113, 60, 8, 92, 103, 71, 130]
2628
87
[-79, 32, -45, -57, 60, 49, -25, -15, 47, -7, -43, 28, 53, -5, 38, -51, -7, 3, 43, 55, 42, -16, -50, 26, -27, -79, 5, 16, -16, 43]

1、append() 方法。向列表末尾追加元素

list.append(element)

element 必需。任何类型（字符串、数字、对象等）的元素

2、random() 方法返回随机生成的一个实数，它在[0,1)范围内。

import random

random.random()

注意：random()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

3、random.randint() 方法返回指定范围内的整数。

randint(start, stop) 等价于 randrange(start, stop+1)。

random.randint() 方法语法如下：

random.randint(start, stop)

start -- 必需， 一个整数，指定开始值。

stop -- 必需， 一个整数，指定结束值。

4、//    取整除 - 返回商的整数部分（向下取整）

例2-20

In?[3]:

matrix = [[1,2,3,4,],[5,6,7,8],[9,10,11,12]]#转置矩阵【列表的嵌套】

print(matrix)

print([[row[i] for row in matrix] for i in range(4)])#列表推导式

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

例2-21

In?[1]:

tup = tuple('bar')

print("输出元组tup：",tup)

nested_tup = (4,5,6),(7,8)

print("输出元组tup：",nested_tup)

print('元组的连接',tup + tuple('wwy'))

a,b,c = tup#元组的拆分

print(a,b,c)

print(tup.count(a))

输出元组tup： ('b', 'a', 'r')
输出元组tup： ((4, 5, 6), (7, 8))
元组的连接 ('b', 'a', 'r', 'w', 'w', 'y')
b a r
1

元组 tuple() 函数将列表转换为元组。

元组和字符串一样，不可改变，即不能给元组的一个独立的元素赋值。

tuple( iterable ) ? iterable -- 要转换为元组的可迭代序列。

例2-22

In?[5]:

scientists = {'Newton':1642,'Darwin':1809,'Turing':1912}#三个键值对

print(scientists.keys())#返回所有的键

print(scientists.values())#返回所有值

print(scientists.items())#返回所有键值对，形式(键, 值)

print(scientists.get('Curie',1867))

temp = {'Curie':1867,'Hopper':1906,'Franklin':1920}

scientists.update(temp)#用字典temp更新字典scientists

print(scientists)

scientists.clear()#清空字典

print(scientists)

dict_keys(['Newton', 'Darwin', 'Turing'])
dict_values([1642, 1809, 1912])
dict_items([('Newton', 1642), ('Darwin', 1809), ('Turing', 1912)])
1867
{'Newton': 1642, 'Darwin': 1809, 'Turing': 1912, 'Curie': 1867, 'Hopper': 1906, 'Franklin': 1920}
{}

字典(Dictionary) 也称映射，是一个由键/值对组成的非排序可变集合体。

键值对在字典中以下面的方式标记： dict = {key1 : value1, key2 : value2 }

键/值对用冒号分割，而各个元素之间用逗号分割，所有元素都包括在花括号中。值得注意的是，字典中的键必须是唯一的，只能使用不可变的对象（比如字符串）来作为字典的键，字典中的键/值对是没有顺序的

内置函数：

1   cmp(dict1, dict2) 比较两个字典元素。

2   len(dict) 计算字典元素个数，即键的总数。

3   str(dict) 输出字典可打印的字符串表示。

4   type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

字典包含了以下内置方法：

1   dict.clear() 删除字典内所有元素

2   dict.copy() 返回一个字典的浅复制

3   dict.fromkeys(seq[, val]) 

创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

4   dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

5   dict.has_key(key) 如果键在字典dict里返回true，否则返回false

6   dict.items() 以列表返回可遍历的(键, 值) 元组数组

7   dict.keys() 以列表返回一个字典所有的键

8   dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

9   dict.update(dict2) 把字典dict2的键/值对更新到dict里

10  dict.values() 以列表返回字典中的所有值

11  pop(key[,default])

删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

12  popitem() 返回并删除字典中的最后一对键和值。

例2-23

In?[7]:

set1 = set([0,1,2,3,4])

set2 = set([1,3,5,7,9])

print(set1.issubset(set2))

print(set1.union(set2))

print(set2.difference(set1))

False
{0, 1, 2, 3, 4, 5, 7, 9}
{9, 5, 7}

集合（set）是一个无序的不重复元素序列。【集合是一个由唯一元素组成的非排序集合体。也就是说，集合中的元素没有特定顺序，集合中没有重复项】可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式:parame = {value01,value02,...}或者set(value)

内置的函数:

set的一些方法：

add()   为集合添加元素

clear() 移除集合中的所有元素

copy()  拷贝一个集合

difference()    返回多个集合的差集

difference_update() 移除集合中的元素，该元素在指定的集合也存在。

discard()   删除集合中指定的元素

intersection()  返回集合的交集

intersection_update()   返回集合的交集。

isdisjoint()    判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

issubset()  判断指定集合是否为该方法参数集合的子集。

issuperset()    判断该方法的参数集合是否为指定集合的子集

pop()   随机移除元素

【pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。】

remove()    移除指定元素

symmetric_difference()  返回两个集合中不重复的元素集合。

symmetric_difference_update()   移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

union() 返回两个集合的并集

update()    给集合添加元素

x in s{用set创建的一个对象}

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>> thisset = set(("Google", "Runoob", "Taobao"))

>>> "Runoob" in thisset

True

>>> "Facebook" in thisset

False

例2-24

In?[8]:

def fact(n):#自定义函数

    if n == 1:

        return 1

    else:

        f = 1

        i = 2

        while(i<=n):

            f = f * i

            i = i + 1

        return f

num = eval(input('请输入一个整数：'))

print(fact(abs(int(num))))#求n的阶乘

请输入一个整数：4
24

函数是对程序逻辑进行过程化和结构化的一种方法，函数最大的优点是增强了代码的重用性和可读性。Python不但能灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

def  function_name(arguments):

function_block ?

关于函数定义的说明：

1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()；

2. function_name是用户自定义的函数名称；

3. arguments是零个或多个参数，且任何传入参数必须放在圆括号内；

4. 最后必须跟一个冒号(:)，函数体从冒号开始，并且缩进；

5. function_block实现函数功能的语句块。

1、eval() 函数用来执行一个字符串表达式，并返回表达式的值。

eval(expression[, globals[, locals]])

expression -- 表达式。

globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回表达式计算结果。

2、abs(x) 函数返回数字x的绝对值。x -- 数值表达式

例2-25

In?[9]:

polynominal = lambda x,y,z:1 + 2 * x + y ** 2 + z * y

polynominal(1,2,3)#将1，2，3分别带入计算

Out[9]:

13

lambda 函数是一种小的匿名函数。并且该函数可接受任意数量的参数，但只能有一个表达式。

lambda arguments : expression执行表达式并返回结果

把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。

对于lambda函数作为匿名函数的额外例子：

In?[10]:

def myfunc(n):

  return lambda a : a * n#该函数定义来创建一个总是使所发送数字加倍的函数

mytripler = myfunc(3)

print(mytripler(11))#使用相同的函数定义来创建一个总是使您发送的数字增加三倍的函数

33

In?[11]:

def myfunc(n):

  return lambda a : a * n

mydoubler = myfunc(2)

mytripler = myfunc(3)

print(mydoubler(11))

print(mytripler(11))#在同一程序中使用相同的函数定义来生成两个函数：

22
33

例2-26

In?[6]:

file = open('泰戈尔的诗.txt',mode = 'r')

content = file.read()

print(content)

file.close()

#有这样一位诗人。他的诗，让世界上无数人，走出消极，甚至治愈了一个民族的痛。
#他就是，诗人之王泰戈尔。
#下面是泰戈尔的一些经典语录
1. 生如夏花之绚烂，死如秋叶之静美。
2. 眼睛为她下着雨，心却为她打着伞，这就是爱情。
-
3. 世界以痛吻我，要我报之以歌。
###
5. 当你为错过太阳而哭泣的时候，你也要再错过群星了。
6. 我们把世界看错，反说它欺骗了我们。
-
7. 不要着急，最好的总会在最不经意的时候出现。

一般的文件处理过程为：

1. 打开文件：open()函数；

2. 读取/写入文件：read()、readline()、readlines()、write()等；

3. 对读取到的数据进行处理；

4. 关闭文件：close()。

1.read([size])读取文件所有内容，返回字符串类型，参数size 表示读取的数量，以byte为单位，可以省略

2.readline([size])读取文件一行的内容，以字符串形式返回，若定义了size，则读出一行的一部分

3.readlines([size])读取所有的行到列表里面[line1,line2,...lineN]，(文件每一行是list的一个成员)，参数size表示读取内容的总长)

1. 文件的写入

write() 函数用于向文件中写入指定字符串，同时需要将open函数中文件打开的参数设置为 mode = w。其中，write() 是逐次写入，writelines() 可将一个列表中的所有数据一次性写入文件。如果有换行需要，则要在每条数据后增加换行符，同时用“字符串 .join() ”的方法将每个变量数据联合成一个字符串，并增加间隔符 “\t”。

2. 关闭文件

文件操作完毕，一定要关闭文件close()，以便释放资源供其他程序使用。

例2-27

In?[4]:

file = open("泰戈尔的诗.txt",mode = 'r')

content = file.read(10)

print(content)

file.close()

print(type(content))

#有这样一位诗人。他
<class 'str'>

例2-28

In?[5]:

file = open("泰戈尔的诗.txt",mode = 'r')

content = file.readlines()

print(content)

file.close()

['#有这样一位诗人。他的诗，让世界上无数人，走出消极，甚至治愈了一个民族的痛。\n', '#他就是，诗人之王泰戈尔。\n', '#下面是泰戈尔的一些经典语录\n', '1. 生如夏花之绚烂，死如秋叶之静美。\n', '2. 眼睛为她下着雨，心却为她打着伞，这就是爱情。\n', '-\n', '3. 世界以痛吻我，要我报之以歌。\n', '###\n', '5. 当你为错过太阳而哭泣的时候，你也要再错过群星了。\n', '6. 我们把世界看错，反说它欺骗了我们。\n', '-\n', '7. 不要着急，最好的总会在最不经意的时候出现。']

例2-29

In?[15]:

import csv

with open ("student.csv",'r') as f:#with open打开的文件，用完自动关闭

    reader = csv.reader(f)

    rows = [row for row in reader]

for item in rows:

    print(item)

CSV (Comma Separated Values)，即逗号分隔值，也称为字符分隔值，因为分隔符除了逗号，还可以是制表符，是一种常用的文本格式，用以存储表格数据，包括数字或者字符。

csv模块实现用于以 CSV 格式读取和写入表格数据的类。 csv模块的reader和writer对象读取和写入序列。 程序员还可以使用DictReader和DictWriter类以字典形式读取和写入数据

CSV文件具有如下特点：

1. 纯文本，使用某个字符集，比如ASCII、Unicode或GB2312；

2. 以行为单位读取数据，每行一条记录；

3. 每条记录被分隔符分隔为字段；

4. 每条记录都有同样的字段序列。

Python内置了csv模块，import csv之后就可以读取CSV文件了

1) csv.writer()

csv 模块中的 writer 类可用于读写序列化的数据，其语法格式如下：

writer(csvfile, dialect='excel', **fmtparams)

csvfile：必须是支持迭代(Iterator)的对象，可以是文件(file)对象或者列表(list)对象。

dialect：编码风格，默认为 excel 的风格，也就是使用逗号,分隔。

fmtparam：格式化参数，用来覆盖之前 dialect 对象指定的编码风格

csv.DictWriter() 使用 DictWriter 类以字典的形式读写数据?

2)csv,reader()

csv 模块中的 reader 类和  DictReader 类用于读取文件中的数据，其中 reader() 语法格式如下：

csv.reader(csvfile, dialect='excel', **fmtparams)

csv模块实现用于以 CSV 格式读取和写入表格数据的类。 csv模块的reader和writer对象读取和写入序列。 程序员还可以使用DictReader和DictWriter类以字典形式读取和写入数据。

csv.reader  返回一个遍历 CSV 文件各行的读取器对象，允许使用带有delimiter属性的不同定界符。items.csv包含用“ |”分隔的值 字符

csv.writer  返回将数据写入 CSV 文件的写入器对象。

该方法返回一个 writer 对象，该对象将用户数据转换为给定文件状对象上的定界字符串。

writerow()方法将一行数据写入指定的文件

csv.register_dialect    注册 CSV 方言

csv.unregister_dialect  注销 CSV 方言

csv.get_dialect 返回具有给定名称的方言

csv.list_dialects   返回所有已注册的方言

csv.field_size_limit    返回解析器允许的当前最大字段大小

csv.DictReader类的操作类似于常规读取器，但会将读取的信息映射到字典中。 字典的键可以使用fieldnames参数传入，也可以从 CSV 文件的第一行推断出来。文件的第一行包含字典键

例2-30

In?[14]:

import csv

content = [['0','hanmeimei','23','81'],

          ['1','mayi','18','99'],

          ['2','jack','21','89']]

f = open('test1.csv',"w")

content_out = csv.writer(f)

for con in content:

    content_out.writerow(con)

f.close

Out[14]:

<function TextIOWrapper.close()>

例2-31

In?[13]:

def skip_header(f):
?   
????line = f.readline()

    while line.startswith('#'):

        line = f.readline()

    return line

def process_file(f):

    line = skip_header(f).strip()

    print(line)

    for line in f:

        if line.startswith("-") or line.startswith("#"):

            line = f.readline()

        line = line.strip()

        print(line)

input_file = open("泰戈尔的诗a.txt","r")

process_file(input_file)

input_file.close()

1. 生如夏花之绚烂，死如秋叶之静美。
2. 眼睛为她下着雨，心却为她打着伞，这就是爱情。
3. 世界以痛吻我，要我报之以歌。
5. 当你为错过太阳而哭泣的时候，你也要再错过群星了。
6. 我们把世界看错，反说它欺骗了我们。
7. 不要着急，最好的总会在最不经意的时候出现。

编程题

In?[3]:

vec = [1,-2,3,-4,5,-6]

vec.sort()
print(vec)
print([x * x for x in vec if x<0])

[-6, -4, -2, 1, 3, 5]
[36, 16, 4]

In?[7]:

str = "abcd"

#str[::-1]

''.join(reversed('abcd'))

Out[7]:

'dcba'

In?[6]:

def fac(m):

     f = 1

     for i in range(1,m+1):

         f = f * i

     return f

n = int(input('请输入一个整数：'))

sum = 0

for i in range(1,n+1):

     sum = sum + fac(i)

print("1!+2!+...+n!=%d" %sum)

请输入一个整数：4
1!+2!+...+n!=33

实训题

In?[3]:

import csv

f = open("white_wine.csv","r")

reader = csv.reader(f)

data = []

for row in reader:

     data.append(row)

for i in range(5):

     print(data[i])

f.close()

['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar', 'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density', 'pH', 'sulphates', 'alcohol', 'quality']
['7', '0.27', '0.36', '20.7', '0.045', '45', '170', '1.001', '3', '0.45', '8.8', '6']
['8.1', '0.28', '0.4', '6.9', '0.05', '30', '97', '0.9951', '3.26', '0.44', '10.1', '6']
['7.2', '0.23', '0.32', '8.5', '0.058', '47', '186', '0.9956', '3.19', '0.4', '9.9', '6']
['7.2', '0.23', '0.32', '8.5', '0.058', '47', '186', '0.9956', '3.19', '0.4', '9.9', '6']

In?[4]:

quality_list = []

for row in data[1:]:

    quality_list.append(int(row[-1]))

#print(quality_list)

quality_count = set(quality_list)

print("白葡萄酒共有%d种等级，分别是：%r" %(len(quality_count),quality_count))

白葡萄酒共有7种等级，分别是：{3, 4, 5, 6, 7, 8, 9}

In?[5]:

?content_dict = {}

for row in data[1:]:

    quality = int(row[-1])

    if quality not in content_dict.keys():

        content_dict[quality] = [row]

    else:

        content_dict[quality].append(row)

for key in content_dict:

     print(key,":",len(content_dict[key]))

#print(content_dict.items())

6 : 1539
5 : 1020
7 : 616
8 : 123
4 : 115
3 : 14
9 : 4

In?[6]:

mean_list = []

for key,value in content_dict.items():

    sum = 0

    for row in value:

        sum += float(row[0])

    mean_list.append((key,sum/len(value)))

for item in mean_list:

    print(item[0],":",item[1])

6 : 6.812085769980511
5 : 6.907843137254891
7 : 6.755844155844158
8 : 6.708130081300811
4 : 7.052173913043476
3 : 7.535714285714286
9 : 7.5

文章撰写不易，转载或者引用时请注明出处，谢谢！