Python笔记（2）

一.字典

 

1.定义

是另一种可变容器模型，且可存储任意类型对象。

2.组成

键key（类似于数据元素）和值value（类似于数据元素项）———字典（类似于数据对象）

                                    

3.操作

• 访问字典里的值

dict={'name':'小明','age':'19','class':'一班'}

print("dict['name']",dict['name'])
print("dict['age']",dict['age'])
print("dict['class']",dict['class'])

• 修改字典

dict={'name':'小明','age':'19','class':'机电一班'}

dict['name']='小红'
print("dict['name']",dict['name'])
print("dict['age']",dict['age'])
print("dict['class']",dict['class'])

• 删除字典

del dict [ 'name' ]  #删除name

dict.clear()            #清空字典

del  dict               #删除字典

• 字典键的特性

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行 

4.函数

• 计算字典元素个数，即键的总值：len（dict）
• 输出字典：str（dict）
• 返回输入的变量类型：type（dict）

1	radiansdict.clear() 删除字典内所有元素
2	radiansdict.copy() 返回一个字典的浅复制
3	radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	radiansdict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict 如果键在字典dict里返回true，否则返回false
6	radiansdict.items() 以列表返回一个视图对象
7	radiansdict.keys() 返回一个视图对象
8	radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10	radiansdict.values() 返回一个视图对象
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem() 随机返回并删除字典中的最后一对键和值。

二.模块

1.定义

如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件就是块。

2.引用

• 引用标准库

#文件名：using_sys.py

import sys #引入python标准库中的sys.py模块

print('命令行参数如下：')
for i in sys.argv:  #sys.arge是一个包含命令行参的列表
    print(i)

print('\n\nPython 路径为：',sys.path,'\n') #sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表

三.Python3面向对象

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1.类定义

可以通过类名访问其属性，__init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上

#格式

class Student:

     <声明1>

     ............

    <声明N>

2.对象

• 属性引用：Python 中所有的属性引用一样的标准语法：obj.name
• 实例化：类命名空间中所有的命名都是有效属性名

1. 无参数的

• class student:
     i=111              #类里边的一个属性
     def f(self)：        #类里边的一个属性
         return "Hello World"
  
  x=student()  #实例化
  
  print("MyClass 类的属性 i 为：",x.i)
  print("MyClass 类的属性 f() 为：",x.f())

  （2）.有参数的：参数通过__init__传递到实例化操作上

• class Student:
     def __init__(self,name,num)：    #方法构造
        self.name=name
        self.num=num
  
  x=Student('小明',20)   #参数传输
  
  print(x.name,x.num)

• self是代表类的实例，类方法必须有一个额外的第一参数名称，一般我们将它写为self（不是关键字，可以用别的来替换），这个参数是代表对象的地址 

• class Text:
     def prt(self):
         print(self)  #看一下class是否是地址
         print(self.class)  #看一下self.class是否指向对象
  
  t=text()
  t.prt()

3.类方法

在类的内部，使用 def 关键字来定义一个方法

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

4.继承

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用

#定义
class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

5.多继承

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

#定义
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

6.方法重写

 
class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

四.面向对象化作业

【问题】
人和机器猜拳游戏写成一个类，有如下几个函数：
1）函数1：选择角色 1 曹操 2张飞 3 刘备
2）函数2：角色猜拳 1剪刀 2石头 3布 【玩家输入一个1-3的数字】
3）函数3：电脑出拳 随机产生1个1-3的数字，提示电脑出拳结果
4）函数4：角色和机器出拳对战，对战结束后，最后出示本局对战结果…赢…输,然后提示用户是否继续？【按y继续，按n退出】
5）最后结束的时候输出结果 角色赢几局 电脑赢几局，平局几次 游戏结束2、人和机器猜拳游戏写成一个类，有如下几个函数：
【思路】
主部分：人机交互，嵌入角色选取和玩家出拳
将角色和猜拳对应的数值用字典来表示
【难点】
1.判断玩家和电脑的输赢的算法(剪刀1-布3==-2，石头2-剪刀1===1，布3-石头2==1)
2.电脑随机出拳，直接用随机函数
【问题】
1.用print会出错误，所以有值传递的时候用的事return
2. could not convert string to float:把减号两边位置调换
3.int（）如果要转负数的浮点要先转float在转int

import random #导入随机函数，后边电脑随机出拳需要用到

#类定义
class YX():
    role_dict={1:"曹操",2:"张飞",3:"刘备"}  #字典定义
    CQ_dict={1:"剪刀",2:"石头",3:"布"}
    #获取角色函数
    def get_role_name(self):
        role_num=int(input("请选择角色：1.曹操 2.张飞 3.刘备\n"))
        return self.role_dict[int(role_num)]
    #获取剪刀石头布
    def get_role_CQ(self):
        CQ_num=input("请出拳：1.剪刀 2.石头 3.布\n")
       # return self.CQ_dict[int(CQ_num)]
        return int(CQ_num)
    #电脑出拳
    def get_computer_CQ(self):
        CQ_num=random.randint(1,3)
        print("电脑出拳：{}",format(CQ_num))
       # return self.CQ_dict[int(CQ_num)]
        return  int(CQ_num)
    #人机交互
    def games(self):
        role_win=0 #角色赢
        computer_win=0 #电脑赢
        PJ=0  #平局
        role_name=self.get_role_name() #获取角色名字
        while True:   #反复进行游戏，直到按下N退出
            role_CQ=self.get_role_CQ()  #角色猜拳
            computer_CQ=self.get_computer_CQ() #电脑猜拳
            print(role_name+"出拳为{},电脑出拳为{}".format(self.CQ_dict[role_CQ],self.CQ_dict[computer_CQ])) #输出玩家和电脑的猜拳内容
            if role_CQ-computer_CQ==1 or role_CQ-computer_CQ==-2: #当相减结果为-2或者1时，赢家
                role_win+=1
                print("玩家赢！")
            elif role_CQ-computer_CQ==-1 or role_CQ-computer_CQ==2:  #这个不要把computer_CQ作为被减数，否则会报错误（原因我也不知道）
                computer_win+=1
                print("电脑赢了！")
            elif computer_CQ==role_CQ:
                PJ+=1
                print("平局")
            choose=int(input("是否继续游戏？继续请按y 结束请按n"))
            if choose=="n":
                break
        print("玩家赢了{}局，电脑赢了{}局",role_win,computer_win)

if __name__=="__main__":   #用于模块启动的程序入口
    YX().games()      #执行game里边的程序