python模块化、文件操作、格式化输出、类和继承、作用域

模块化 from module import module.function

dir 返回模块内所有定义名称，以字符串列表形式返回

# __name__ 在此运行时为 __main__，不在此运行时为 文件名

print(__name__)
if __name__ == '__main__':
    print('程序在自身运行')
else:
    print('程序不在自身运行')


def add(a, b):
    return a + b

格式化输出，文件操作

import math
import sys
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# 输入和输出，可使用 .format 进行传入数据
print('你好，{}。你{}岁了。'.format('小明', 18))

# 输入和输出，可使用 f'{var1}xxx{var2}' 传入var1 var2的值
name = '小红'
age = 16
print(f'你好，{name}。你{age}岁了。')

# 格式化小数 {0:.4f}保留四位小数，
print('π的近似值：{0:.4f}'.format(math.pi))

# 在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。
table = {'Google': 1, 'R': 2, 'Ta': 3}
for k, v in table.items():
    print('{:10}===>{:10}'.format(k, v))

# 获取当前位置
print(sys.path[0])
# 文件读写 r r+ w w+ a a+
path = sys.path[0] + '\output.txt'
f = open(path, 'w')
f.write('python \n java \n C++')
f.close()
# 读文件
print('-' * 10)
f = open(path, 'r')
str1 = f.read()
print(str1)
f.close()
# 读一行
print('-' * 10)
f = open(path, 'r')
str1 = f.readline()
print(str1)
f.close()
# 读多行，以列表形式返回
print('-' * 10)
f = open(path, 'r')
str1 = f.readlines()
print(str1)
# 迭代读取
print('-' * 10, '迭代读取')
f = open(path, 'r')
for line in f:
    print(line, end='')

# 若果写入的不是字符串则需要转化
print('-' * 10, '写入其他类型数据')
f = open(path, 'w', encoding='utf8')
value = ('test', '测试')
s = str(value)
print(s)
f.write(s)

print(f.tell())

类和继承

创建类和创建实例

# 创建类的时候可声明__init__ 方法，在类被创建时候会执行
# 类中定义的全局属性可通过类名直接访问
# self代表类的实例，而非类
class MyClass:
    p = 0

    def __init__(self, x, i):
        self.x = x
        self.i = i

    def out_function(self):
        print(f'输出方法：x = {self.x}, i = {self.i}')


my_class = MyClass(x=12, i=1)
my_class.out_function()
# 通过类名直接访问属性
print(MyClass.p)


# self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:
class MyClass2:
    def prt(runoob):
        print(runoob)
        print(runoob.__class__)


my_class2 = MyClass2()
my_class2.prt()

类的继承使用

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(f'{self.name}说：我{self.age}岁了，我{self.__weight}公斤。')


class Student(People):
    grade = 0

    def __init__(self, n, a, w, g):
        # 调用父类的初始化方法
        People.__init__(self, n, a, w)
        self.grade = g

    # 覆盖父类的方法
    def student_speak(self):
        # __weight 是私有属性，外部不能访问
        People.speak(self)
        print(f'我在{self.grade}年级。')


# 单继承
print('*' * 10)
p = People('张三', 20, 50)
p.speak()

print('*' * 10)
s = Student('李四', 25, 60, '三')
s.student_speak()
# 调用父类方法，使用super(child,c).method()
super(Student, s).speak()


# 多继承
class Speaker:
    name = ''
    topic = ''

    def __init__(self, name, topic):
        self.name = name
        self.topic = topic

    def speaker_say(self):
        print(f'我是{self.name},我演讲的题目是：{self.topic}。')


class StudentSpeaker(Student, Speaker):
    def __init__(self, n, a, w, g, t):
        Student.__init__(self, n, a, w, g)
        Speaker.__init__(self, n, t)

    def student_speaker(self):
        Student.student_speak(self)
        Speaker.speaker_say(self)


print('*' * 10)
ss = StudentSpeaker('王五', 25, 70, '五', '多继承类')
ss.student_speaker()

python作用域

# python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，
# 其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，
# 也就是说这些语句内定义的变量，外部也可以访问

num = 1


def fun():
    # 使用全局变量
    global num
    print(num)
    # 改变里全局变量
    num = 123
    print(num)


def fun1():
    # 此时使用的是局部变量，不会对全局变量进行更改
    num = 456
    print(num)


# 嵌套情况下使用外部变量，使用nonlocal声明
def outer():
    test = 10

    def inner():
        # 声明使用nonlocal，即使用了外部变量 test = 10
        nonlocal test
        test = 100
        print(test)

    inner()
    print(test)  # 此时test已经被inner内部更改


fun()
print('*' * 10)
print(num)

print('-' * 20)
fun1()
print(num)

print('-' * 20)
outer()