笨方法学python-12(习题39-42)

习题39:列表的操作

ten_things = "Apples Oranges Crows Telephone Light Sugar"
print("Wait there's not 10 things in that list, let's fix that.")
stuff = ten_things.split(' ')
more_stuff = ["Day", "Night", "Song", "Frisbee", "Corn", "Banana", "Girl", "Boy"]
while len(stuff) != 10:
    next_one = more_stuff.pop()
    print("Adding:", next_one)
    stuff.append(next_one)
    print("There's %d items now." % len(stuff))
print("There we go: ", stuff)
print("Let's do some things with stuff.")
print(stuff[1])
print(stuff[-1])
print(stuff.pop())
print(' '.join(stuff))
print('#'.join(stuff[3: 5]))

笨方法学python-12(习题39-42)_第1张图片

1.  将每一个被调用的函数以上述的方式翻译成 Python 实际执行的动作。例如:  ' '.join(things) 其实是  join(' ', things) 

stuff = ten_things.split(' ')实际执行为 stuff = split(ten_things,  ' ')

next_one = more_stuff.pop()实际执行为 next_one = pop(more_stuff)

stuff.append(next_one)实际执行为 append(stuff, next_one)

stuff.pop()实际执行为 pop(stuff)

'#'.join(stuff[3:5]实际执行为join('#', stuff[3:5])

2. 将这两种方式翻译为自然语言。例如,  ' '.join(things) 可以翻译成“用 ‘ ‘ 连接(join) things”,而  join(' ', things) 的意思是“为 ‘ ‘ 和 things 调用 join函数”。这其实是同一件事情。

3. 上网阅读一些关于“面向对象编程(Object Oriented Programming)”的资料。晕了吧?嗯,我以前也是。别担心。你将从这本书学到足够用的关于面向对象编程的基础知识,而以后你还可以慢慢学到更多。

4. 查一下 Python 中的 “class” 是什么东西。不要阅读关于其他语言的 “class” 的用法,这会让你更糊涂。

5.  dir(something) 和  something 的 class 有什么关系?

6. 如果你不知道我讲的是些什么东西,别担心。程序员为了显得自己聪明,于是就发明了 Opject Oriented Programming,简称为 OOP,然后他们就开始滥用这个东西了。如果你觉得这东西太难,你可以开始学一下 “函数编程(functionalprogramming)”。


习题40:字典,可爱的字典

开始学习容器型数据结构——字典(dictionary)

与列表的区别

列表使用数字为索引,[ ]

字典使用任何东西作为索引,{ }

things = ['a', 'b', 'c', 'd']
print(things[1])
things[1] = 'z'
print(things[1])
print(things)

stuff = {'name': 'Zed', 'age': 36, 'height': 6*12+2}
print(stuff['name'])
print(stuff['age'])
print(stuff['height'])
stuff['city'] = 'San Francisco'
print(stuff['city'])
stuff[1] = "Wow"
print(stuff[1])
print(stuff)
del stuff[1]
del stuff['age']
print(stuff)
笨方法学python-12(习题39-42)_第2张图片
cities = {'CA': 'San Francisco', 'MI': 'Detroit', 'FL': 'jacksonville'}
cities['NY'] = 'New York'
cities['OR'] = 'Portland'
def find_city(themap, state):
    if state in themap:
        return themap[state]
    else:
        return "Not found."
#cities['_find'] = find_city
while True:
    print("State? (ENTER to quit) ", end='')
    state = input(">")
    if not state : break
    city_found = find_city(cities, state)
    print(city_found)

笨方法学python-12(习题39-42)_第3张图片

1.  在 Python 文档中找到 dictionary (又被称作 dicts, dict)的相关的内容,学着对 dict做更多的操作。

2. 找出一些 dict 无法做到的事情。例如比较重要的一个就是 dict 的内容是无序的,你可以检查一下看看是否真是这样。

3. 试着把  for-loop 执行到 dict 上面,然后试着在 for-loop 中使用 dict的  items() 函数,看看会有什么样的结果。

返回可遍历的元组数组

dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}
print("字典值: %s" %dict.items())
for key, value in dict.items():
    print(key,value)



习题41:(这题目……)

长长的代码,不贴上来了。


习题42:物以类聚

用到class的编程语言被称为“面向对象编程”

class TheThing(object):
    def __init__(self):
        self.number = 0
    def some_function(self):
        print("I got called.")
    def add_me_up(self, more):
        self.number += more
        return self.number
a = TheThing()
b = TheThing()
a.some_function()
b.some_function()
print(a.add_me_up(20))
print(a.add_me_up(20))
print(b.add_me_up(30))
print(b.add_me_up(30))
print(a.number)
print(b.number)

笨方法学python-12(习题39-42)_第4张图片

重点需要理解这些东西:

1. 怎样创建一个  class Game(object) 并且放函数到里边去。

2.  __init__ 是一个特殊的初始方法,可以预设重要的变量在里边。

3. 为 class 添加函数的方法是将函数在 class 下再缩进一阶,class 的架构就是通过缩进实现的,这点很重要。

4. 你在函数里的内容又缩进了一阶。

5. 注意冒号的用法。

6. 理解  self 的概念,以及它在  __init__ 、  play 、  death 里是怎样使用的。

7. 研究  play 里的  getattr 的功能,这样你就能明白  play 所做的事情。其实你可以手动在 Python 命令行实验一下,从而弄懂它。

8. 最后我们怎样创建了一个  Game ,然后通过  play() 让所有的东西运行起来


研究一下  __dict__ 是什么东西,应该怎样使用。

返回类或者对象的所有成员

对类:输出全部的函数以及变量等信息

对对象:输出成员变量






关于面向对象这一块内容光看这部分的习题没能很好的理解。学习一下廖雪峰的python教程


面向对象编程(Object Oriented Programming,OOP),把对象作为程序的基本单元,一个对象包含数据和操作数据的函数

python中,所有数据类型可以视为对象。自定义的对象数据类型就是面向对象中的类(class)的概念。

面向对象的三大特点:封装、继承、多态(继承的一个好处是多态)

用class创建类,类是创建实例的模板,而实例是具体的对象,实例之间的数据相互独立

创建实例时可以添加属性,__init__方法的第一个参数永远是self,表示创建的实例本身,调用时不必传递该参数。这也是与普通函数相比,在类中定义的函数的不同点。

封装:在类的内部定义定义访问数据的函数。封装数据的函数和类本身关联,成为类的方法,即与实例绑定的函数,方法可以直接访问实例的数据。

封装的好处:1、调用容易;2、可以给类增加新的方法

如果内部属性不想被外部访问,属性前加上__,如__name,实例的变量名就变成了私有变量;

如果需要访问私有变量,添加get_name这样的方法;修改的话添加set_name

class Student(object):
    ...

    def get_name(self):
        return self.__name

    def set_score(self, score):
        self.__score = score



你可能感兴趣的:(python)