Python人工智能 - A计划（永久有效期） 扫二维码继续学习 二维码时效为半小时

try:
    a = 10
    b = 1
    print(a/b)
except ZeroDivisionError:
    print('there is a error')
else:
    print('no error')

print('end')

• print(9/0)是可能会出错的代码
• 如果出错，则会执行except后的代码
• 如果不出错，则不会执行except
• else是在没有出错时执行的（一般用的比较少）

读取每一行的另一种方式：

with open('game.txt') as file:
   l = file.readlines()

   for line in l:
       print(line)
 

写入新的数据：

#覆盖模式   'w'代表写入-覆盖
with open('game.txt', 'w') as file:
    file.write('abc')

#附加模式   'a'代表写入-附加
with open('game.txt', 'a') as file:
    file.write('\nefg')

#只读的话，后面加'r'

读取整个文件：

with open('game.txt') as file:
    content = file.read()

    print(content)

读每一行：

with open('game.txt') as file:
    for line in file:
        print(line)

import os #导入操作系统
print(os.getcwd()) #获取当前的目录位置

#修改工作目录：
os.chdir('C:\\Users\\Administrator\\Desktop\\siki学院学习\\22')
#在程序里写时要写两个斜杠来代表一个斜杠，或者写一个反斜杠
print(os.getcwd()) 

创建文件：（也要先import os）

  #相对路径
os.makedirs('22/11')
  #绝对路径
os.makedirs('C:\\Users\\Administrator\\Desktop\\siki学院学习\\22\\33')

cd + 路径名，则为打开

路径名+cd..，则为关闭

分为绝对路径和相对路径

绝对路径：全部路径信息

相对信息：当前路径下的位置

把weapon放在一个单独的模块里（文件里）

1. import weapon

2. from weapon import Weapon

使用方法1时，下面引用也要加上地址，如

self.weapon = weapon.Weapon(damage, bulletCount)

class Weapon():
    def __init__(self, damage, bulletCount):
        self.damage = damage
        self.bulletCount = bulletCount
    def attack(self):
        print('a shot, damage is ' + str(self.damage))
        
class Role():
    def __init__(self, name, lv, roleType,damage, bulletCount):
        self.name = name
        self.lv = lv
        self.roleType = roleType
        self.weapon = Weapon(damage, bulletCount) #这里是直接传递了weapon类作为属性

    def move(self):
        print(self.name + ' is walking')

    def attack(self):
        self.weapon.attack() #这里也直接调用weapon的

role = Role('sk', 20, 'mfs', 20, 20)
role.move()
role.attack()

#这里Person就是父类
class Teacher(Person): 
    def __init__(self, name, age, title): #在这里直接添加子类的特有属性
        super().__init__(name,age) #调用父类里的初始化方法，也叫构造方法
        self.title = title

    def teach(self):
        print(self.name + ' is teaching')

# 当某个父类属性需要被重写时：
    def eat(self):
        print(self.name + ' eating at restaurant')

t1 = Teacher('sk',50,'高级教师')
t1.eat()
t1.teach()
 

#这里Person就是父类
class Teacher(Person): 
    def __init__(self, name, age):
        super().__init__(name,age)

#上一行调用父类里的初始化方法，也叫构造方法

t1 = Teacher('sk',50)
t1.eat()

修改属性：

可以在属性里加个函数：

def get_mileage(self):
        print('the mileage is ' + str(self.mileage))

调动时：

car1.set_mileage(100)

再比如，增加里程：

def add_mileage(self,mileage):
        if self.mileage >= 0:
            self.mileage += mileage

添加属性的默认值：

class Car():
    def __init__(self, make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.mileage = 0

    def describe(self):
        print(self.year + ' ' + self.make + ' ' + self.model)

    def get_mileage(self):
        print('the mileage is ' + str(self.mileage))

car1 = Car('奥迪', 'K1', '2010')
car1.describe()
car1.get_mileage()

#类后面加的首字母大写，其他都是小写（规范里）
class Dog():
    # __init__ 这个函数用来表示类里有哪些变量,只有这个是特殊函数,这个函数和self是必须写的
    def __init__(self, name, age, color):
        #通过self.name添加了一个属性，等号右面的name是传递过来的参数
        self.name = name
        self.age = age
        self.color = color
        #上面init是初始化

#所有函数里都要写self
    def sit(self):
        print(self.name + ' I sit')

    def rollOver(self):
        print(self.name + ' da gun')

    #实例 实际例子（叫做对象）
    #dog1是对象名，也是一个变量名
        #这里Dog后括号里不用写self
dog1 = Dog('dabai',2,'black')

dog2 = Dog('xiaoxiao',3,'white')

#self是变的，当运行dog1时，self就是dog1
print(dog1.name)
print(dog2.name)
dog1.sit()
dog2.sit()

dog1.rollOver()
 

#类后面加的首字母大写，其他都是小写（规范里）
class Dog():
    # __init__ 这个函数用来表示类里有哪些变量,只有这个是特殊函数,这个函数和self是必须写的
    def __init__(self, name, age):
        #通过self.name添加了一个属性，等号右面的name是传递过来的参数
        self.name = name
        self.age = age
        #上面init是初始化

#所有函数里都要写self
    def sit(self):
        print('I sit')

    def rollOver(self):
        print('da gun')

#这两个是添加的行为

类-面向对象

包含两个部分：类的创建、类的使用（对象）

类名：习惯大写

class Dog():
    # __init__ 这个函数用来表示类里有哪些变量,只有这个是特殊函数,self是必须写的
    def __init__(self, name, age):
        self.name = name
        self.age = age

上面是在进行初始创建

使用递归调用时，记得设置好终止的条件

利用递归的方法，计算：

f(n)=1+2+3+...+n

分析：

F(n-1)=1+2+3+...+n-1

F(n)=f(n-1)+n

F(1) = 1 --终止条件

例子：

def f(n):
    if n == 1:
        return 1
    he = f(n-1)+n
    return he

print(f(5))

讲解：如果没有达到n==1的条件，则会调用下面的递归，如果达到了，则之间返回1。对于下面的的he = f(n-1)+n，每个f(n-1)都会从头开始执行这个函数，即从判断n==1开始

如何只导用模块里的某一个方法，而不是整个模块：

使用 from 模块名 import 方法1, 方法2

使用此方法，则使用方法时可以不加模块名

但其实仍可能重名，则此时可以给方法起别名，在上面的‘方法n’后面加‘as 新名’，例如：

from test import test2 as t

t()

还可以给模块起别名：

import test as t

导入某个模块的所有函数的方式：

1. import test

2. import test import * 

方法2很少用，因为如果不清楚里面的函数，则容易与当前的重名

命名规则：

1. 可以简单，但不能太简单，如student可以为stu，但不能是s

2. 驼峰命名法：几个单词命名，则后面的单词首字母大写，如stuScore，myFatherName

3. 单词之间用下划线连接

Python有自己的常用模块，用import导入

定义自己的模块并导入：

• Python里一个文件就是一个模块，模块名就是文件名。所以创建py文档即可
• 注意当前的文件与要引用的目录要在同一个目录下
• 不加后缀
• 使用模块的方法时，前面要加上mok

例子： 

import test

test.test1()

可变个数的参数，使用*+变量名

def test(*n):
    print(n)

test()
test(1)
test(3)

则输出的是元组

如果有可变个数参数，则需要放在其他参数的后面

函数和字典结合使用：

def test(n,a):
    d = {'name': n, 'age': a}
    return d

print(test('siki','18'))

函数和列表结合使用：

如果给函数传递了列表，则函数里的会对原列表进行修改，例如：

l = [ 'siki' , 'libai' , 'dufu' ]
def test(l):
    del(l[1])

test(l)
print(l)

则l里的‘libai’会删掉

如何不使原函数发生变化？复制一份，例如：

l = [ 'siki' , 'libai' , 'dufu' ]
def test(l):
    del(l[1])

test(l[:])
print(l)

全局变量和局部变量重名的情况：

1. 访问局部（这个函数自己）时，会使用局部变量的值

2. 在函数外访问这个变量时，会使用全局变量

在局部里修改全局的值：

用 global + 变量名，例如：

name = 'globalname'
def test():
    global name
    name = 'localname'
    print(name)

test()
print(name)