Python基础知识学习笔记

学习资源——Python123

5 字典

无序，可以理解为现实字典，“查字典”。

dictionary_name = {key_1: value_1,
               key_2: value_2
               }

字典的定义

如上，花括号定义。

>>> words={'python':'QAQ',
            'c++':'QwQ',
            'Java':'no response'}
   
>>> print("名称:%s" % 'python')
   
名称:python
>>> print("\n解释:%s" % words['python'])
   

解释:QAQ

几种访问方式

#words.items()赋key和value给前面两个值

#words每次赋给word一个key
>>> for word in words:
   print('%s' % word)

python
c++
Java

#words.keys()每次赋给word一个key
>>> for word in words.keys():
   print('%s' % word)

python
c++
Java

#words.values()每次赋给meaning一个value
>>> for meaning in words.values():
   print("%s" % meaning)

QAQ
QwQ
no response

#以key为关键词排序
>>> for word in sorted(words.keys()):
   print("%s : %s" % (word,words[word]))

Java : no response
c++ : QwQ
python : QAQ

添加：直接中括号添加

#def为定义函数
>>> def showMeanings(dictionary):
        for name, meaning in dictionary.items():
            print("\n名称: %s" % name)
            print("解释: %s" % meaning)
>>> showMeanings(words)
   

名称: python
解释: QAQ

名称: c++
解释: QwQ

名称: Java
解释: no response

修改：直接中括号修改

删除：

any = words.pop('string')
del words['string']

修改键名：将原来的值赋给新键，删除旧键

嵌套：值为列表或字典

#值为列表
>>> words = {'a':[1,2,3],'b':[4,5,6],'c':[7,8,9]}
>>> print(words['a'][0])
1

#值为字典
>>> words = {'a':{1:[2,3,4]},'b':{2:[4,7,8]}}
>>> words['a']
{1: [2, 3, 4]}
>>> words['a'][1][2]
4

6.1 函数(Functions)简介

函数的定义

def fun(a,b):
    #It is code in function

fun(c,d)

返回值

使用return返回
用else避免错误返回

练习

Greeter

• 写下一个函数，参数是一个人的名字，并打印出一条祝福的语句。
• 用你的函数祝福3个人。
• 将人名存储在列表中，并且用 for 循环调用函数。

>>> def Greeter(name):
        print("Good luck, %s!" % name)

>>> Greeter("Aaron")
Good luck, Aaron!

>>> Greeter("Bob")
Good luck, Bob!

>>> Greeter("Cindy")
Good luck, Cindy!

>>> names = ["Aaron", "Bob", "Cindy"]
>>> for name in names:
        Greeter(name)

Good luck, Aaron!
Good luck, Bob!
Good luck, Cindy!

Full Names

• 写下一个函数，参数包括姓和名字，并打印出一条包含全名的语句。
• 使用不同的参数，调用 3 次你的函数。

>>> def fn(fname,gname):
       print("Hello, %s %s!" % (gname,fname))

>>> names = [["Wang","Aaron"],["Sun", "Bob"], ["Chen","Cindy"]]
       
>>> for a,b in names:
       fn(a,b)
 
Hello, Aaron Wang!
Hello, Bob Sun!
Hello, Cindy Chen!

Addition Calculator

• 写下一个函数，包含两个数字类型的参数。计算参数的和并打印出参数和它们的和。
• 调用 3 次你的函数。

>>> def ac(x,y):
       z=x+y
       print(z)

>>> numbers = [[1,2],[3,4], [5,6]]
       
>>> for number in numbers:
       ac(number[0],number[1])
 
3
7
11

Return Calculator

• 修改 Addition Calculator 中的函数，返回参数的和。并在函数外打印出来。

>>> def ac(x,y):
    z=x+y
    return z

>>> numbers = [[1,2],[3,4], [5,6]]
       
>>> for number in numbers:
       print(ac(number[0],number[1]))

3
7
11

6.2 函数进阶

参数缺省值

def fun(name='s'):
    #It is the code of function

位置与关键字参数

多参数按照位置传递，可以写形参名来乱序传递参数。

如果使用混合位置和关键字参数，需要位置参数在前，关键字参数在后。

接受任意数量的参数

Python的参数，顺序为位置参数，一星任意数量参数，强制关键词参数，两星多关键词参数，可以单独一星使后面的变为强制关键字参数。

7.1 类(Classes)

>>> class One():
    def __init__(self):
        self.x=0
        self.y=0
    def move(self,xx,yy):
        self.x+=xx
        self.y+=yy
    def show(self):
        print("(%d,%d)" % (self.x,self.y))

>>> ones = [One() for i in range(0,5)]
>>> for i in range(0,5):
    ones[i].move(i,i*i)
    ones[i].show()

(0,0)
(1,1)
(2,4)
(3,9)
(4,16)

7.2 面向对象基础

常用术语

class：类。类是代码块的主体，其中定义了建立的模型的属性和行为。这个模型可以来自于真实世界，也可以是虚拟游戏等。
attribute：属性。是一系列信息的集合。在类中，一个属性通常是一个变量。
behavior：行为。行为是定义在类中，组成方法的部分。也即是定义在类中函数的一部分。
method：方法。类中的函数，由 behavior 组成。
object：对象。对象是类的实例。一个对象中包含所有类中属性的值。你可以为一个类创建任意数量的对象。

One类

init()方法

类名的命名规则和变量的相同，但是 Python 中有一个约定好的规则，类名必须是驼峰式的。也即每个单词的开头必须是大写的，不允许下划线的出现。类名后紧跟一对圆括号，目前为止圆括号里都是空的，接下来的学习中，其中可能会包含一个类。这个类是新类基于的类。

init()初始化函数。

self对当前对象的引用。

创建多个对象

#第一种方法
ones = []
for x in range(0,5):
    new_one = One()
    ones.append(new_one)
#第二种方法
ones = [One() for i in range(0,5)]

7.3改进类

init()、方法中接受参数，添加新方法

7.4 继承(Inheritance)

面向对象程序设计最重要的目的之一就是创建稳定的，可靠的，可重用的代码。如果你为每个对象都创建一个新类，你也很难写出可重用的代码。
在 Python 和任意支持面向对象编程的语言中，一个类可以继承另一个类。这也意味着你可以在旧类的基础上创建新类。新类继承旧类中所有的属性和行为。
新类可以重写覆盖任一继承自旧类的属性或行为。也可以添加新的属性和行为。旧类被称为父类，新类被称为父类的孩子。父类也被称为 superclass ，子类被称为 subclass。
子类继承父类的所有属性和行为，但在子类中定义的属性和行为不能为父类所用。这虽然看起来很明显，但也有必要说明一下。
这也以为着子类可以重写父类中的方法。如果子类中定义了一个已经在父类中出现的方法，子类对象会调用子类的方法而不是父类的。

子类中填写父类的类名，初始化函数中用super().init()初始化父类

随机数

from random import randint
s=randint(0,100)

7.5 模块(Modules)和类

当你将类存储在一个单独的文件中时，这个文件就被称为一个模块（module）。在一个模块中可以写入任意数量的类。而且有很多方式在程序中导入模块中的类。
接着所学类的知识，我们将 Rocket 类存进一个称之为 rocket.py 的文件。需要注意的是，模块的名字是小写的单词，类名是以大写字母开头的。

在模块中储存类

我们将One类存进一个称之为one.py的文件。需要注意的是，模块的名字是小写的单词，类名是以大写字母开头的。

from one import One,(Other_class)
new_one = One()

from one import *
new_one = One()

import one
new_one = one.One()

import one as (other_name)
new_one = (other_name).One()
#注意重名问题

在模块中储存函数

与储存类相同

8 异常(Exceptions)

try/except as/else/finally异常处理

#计算器
class Calculator():
        muffled = True
        #默认抑制错误信息
        flag = True
        #退出标记
        def __init__(self):
                print("Let's start! Press Ctrl+c to exit.\n")
        def calculation(self):
                #计算函数
                try:
                        self.flag = True
                        self.a = input("Please input an expression.\n")
                        print("ans = %d" % eval(self.a))
                except (ZeroDivisionError, TypeError) as e:
                        if not self.muffled:
                                print(e)
                        print("Your number is bogus!\nPlase try again!\n")
                except KeyboardInterrupt:
                        self.flag = False
                        print("Good luck!")
                except Exception as e:
                        if not self.muffled:
                                print(e)
                        print("Something is wrong!\nPlase try again!\n")
                else:
                        print("Successful calculation!\n")
                finally:
                        if self.flag:
                                self.calculation()
        def change(self):
                #改变抑制错误信息的状态
                self.muffled = not self.muffled

raise自定义异常

with/as

工作原理（加粗名字两边各有两条下划线）

• 上下文管理器必须包含 enter 和 exit 方法。
• enter 方法被自动调用，如果存在 as 子句，返回值就被赋值给 as 后的变量，没有就直接丢弃。
• 嵌套在 with 语句下的代码被执行。
• 如果 with 语句中的代码抛出异常， exit(type, value, traceback) 方法就会被调用。参数值是和 sys.exc_info() （Python 内置函数）函数返回值相同的值。如果这个方法返回了一个 false 值，异常就会被重新抛出，否则异常终止。异常重新抛出是以常规方式抛出的，因此在 with 语句外捕获。
• 如果 with 语句里的代码块没有抛出异常，exit 方法仍旧会被调用，但是参数会被置为 None。

class TraceBlock:
    def message(self, arg):
        print('running ' + arg) 
        
    def __enter__(self):
        print('starting with block')
        return self
    
    def __exit__(self, exc_type, exc_value, exc_tb):
        if exc_type is None: 
            print('exited normally\n')
        else:
            print('raise an exception! ' + str(exc_type)) 
            return False # Propagate

with TraceBlock() as action: 
    action.message('test 1')
    print('reached')

with TraceBlock() as action: 
    action.message('test 2') 
    raise TypeError()
    print('not reached')