Python笔记_2基础之关键知识点解析

Posted 2021-10-16 感恩的学习空间

前言导读
本章也是从小编学习的各种资料中提取而来的知识点,
它全面而有简单的介绍了python基础的关键知识点.

1 交互式解释器

在命令行窗口执行python后，进入 Python 的交互式解释器。exit() 或 Ctrl + D 组合键退出交互式解释器。

2 指定解释器

如果在 Python 脚本文件首行输入#!/usr/bin/env python，那么可以在命令行窗口中执行/path/to/script-file.py以执行该脚本文件。

4 编码

默认情况下，3.x 源码文件都是 UTF-8 编码，字符串都是 Unicode 字符。也可以手动指定文件编码：

# -*- coding: utf-8 -*-

或者

# encoding: utf-8

注意: 该行标注必须位于文件第一行

5 标识符

• 第一个字符必须是英文字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。

注：从 3.x 开始，非 ASCII 标识符也是允许的，但不建议。

9 数字运算

• 不同类型的数字混合运算时会将整数转换为浮点数
• 在不同的机器上浮点运算的结果可能会不一样
• 在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //。
• // 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系
• 在交互模式中，最后被输出的表达式结果被赋值给变量 _，_ 是个只读变量

10 Unicode

在 2.x 中，普通字符串是以 8 位 ASCII 码进行存储的，而 Unicode 字符串则存储为 16 位 Unicode 字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在 3.x 中，所有的字符串都是 Unicode 字符串。

11 字节(bytes)

在 3.x 中，字符串和二进制数据完全区分开。文本总是 Unicode，由 str 类型表示，二进制数据则由 bytes 类型表示。Python 3 不会以任意隐式的方式混用 str 和 bytes，你不能拼接字符串和字节流，也无法在字节流里搜索字符串（反之亦然），也不能将字符串传入参数为字节流的函数（反之亦然）。

• bytes 类型与 str 类型，二者的方法仅有 encode() 和 decode() 不同。
• bytes 类型数据需在常规的 str 类型前加个 b 以示区分，例如 b\'abc\'。
• 只有在需要将 str 编码(encode)成 bytes 的时候，比如：通过网络传输数据；或者需要将 bytes 解码(decode)成 str 的时候，我们才会关注 str 和 bytes 的区别。

bytes 转 str：

b\'abc\'.decode() 
str(b\'abc\') 
str(b\'abc\', encoding=\'utf-8\')

str 转 bytes：

\'中国\'.encode()  

bytes(\'中国\', encoding=\'utf-8\')

12 自定义函数

函数（Functions）是指可重复使用的程序片段。它们允许你为某个代码块赋予名字，允许你通过这一特殊的名字在你的程序任何地方来运行代码块，并可重复任何次数。这就是所谓的调用（Calling）函数。

13 参数

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def print_info(name, age):
    "打印任何传入的字符串"
    print("名字: ", name)
    print("年龄: ", age)
    return
print_info(age=50, name="john")

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。

def print_info(name, age=35):
    print ("名字: ", name)
    print ("年龄: ", age)
    return
print_info(age=50, name="john")
print("------------------------")
print_info(name="john")

不定长参数

• 加了星号 * 的参数会以元组的形式导入，存放所有未命名的变量参数。
• 如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

def print_info(arg1, *vartuple):
    print("输出: ")
    print(arg1)
    for var in vartuple:
        print (var)
    return
print_info(10)
print_info(70, 60, 50)

• 加了两个星号 ** 的参数会以字典的形式导入。变量名为键，变量值为字典元素值。

def print_info(arg1, **vardict):
    print("输出: ")
    print(arg1)
    print(vardict)
print_info(1, a=2, b=3)

14 模块

编写模块有很多种方法，其中最简单的一种便是创建一个包含函数与变量、以 .py 为后缀的文件。

另一种方法是使用撰写 Python 解释器本身的本地语言来编写模块。举例来说，你可以使用 C 语言来撰写 Python 模块，并且在编译后，你可以通过标准 Python 解释器在你的 Python 代码中使用它们。

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 Python 标准库的方法。

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块，需要把命令放在脚本的顶端。

一个模块只会被导入一次，这样可以防止导入模块被一遍又一遍地执行。

搜索路径被存储在 sys 模块中的 path 变量。当前目录指的是程序启动的目录。

name 统一属性

每个模块都有一个 __name__ 属性，当其值是 \'__main__\' 时，表明该模块自身在运行，否则是被引入。

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用 __name__ 属性来使该程序块仅在该模块自身运行时执行。

if __name__ == \'__main__\':
    print(\'程序自身在运行\')
else:
    print(\'我来自另一模块\')

dir 函数查看模块定义名称

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回。

如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称。

在 Python 中万物皆对象，int、str、float、list、tuple等内置数据类型其实也是类，也可以用 dir(int) 查看 int 包含的所有方法。也可以使用 help(int) 查看 int 类的帮助信息。

15 包

包是一种管理 Python 模块命名空间的形式，采用”点模块名称”。

比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

最简单的情况，放一个空的 __init__.py 文件就可以了。当然这个文件中也可以包含一些初始化代码或者为 __all__ 变量赋值。

16 迭代器

• 迭代器是一个可以记住遍历的位置的对象。
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
• 迭代器有两个基本的方法：iter() 和 next()。
• 字符串，列表或元组对象都可用于创建迭代器。

迭代器可以被 for 循环进行遍历：

li = [1, 2, 3]
it = iter(li)
for val in it:
    print(val)

迭代器也可以用 next() 函数访问下一个元素值：

import sys

li = [1,2,3,4]
it = iter(li)

while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

17 生成器

• 在 Python 中，使用了 yield 的函数被称为生成器（generator）。
• 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
• 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
• 调用一个生成器函数，返回的是一个迭代器对象。

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f))
    except StopIteration:
        sys.exit()

(本章完)

所有资源均有PDF目录版,如想获得请扫码关注右侧公众号自动获取

python必学的面向对象基础之继承静态与多态

前言

这是我听老师讲课做的笔记

作者：神的孩子都在跳舞

关注我的csdn博客，更多python知识还在更新

一. 析构方法

1. 介绍：当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__()方法，也称为析构方法

2. 代码解析:

class Animal(object):
    def __init__(self,name):#定义__init__方法
        self.name=name#实例属性
        print('init方法被调用')
    def __del__(self):
        print('程序执行结束，自动调用del方法销毁对象%s'%self.name)
dog=Animal('狗')
# 或者直接删除对象也可以自动调用del方法
del dog

input('程序等待中')#这是一个输入函数，说明程序还没结束，可是del方法被执行了

'''输出
init方法被调用
程序执行结束，自动调用del方法销毁对象狗
程序等待中
'''

总结：

1、当整个程序脚本执行完毕后会自动调用__del__方法

2、当对像被手动销毁时也会自动调用 方法

3、析构函数一般用于资源回收，利用__del__方法销毁对象回收内存等资源

二. 继承,调用与重写

2.1 单继承

在现实生活中，继承一般指的是子继承父辈的财产。在面向对象中继承也是同样道理，不过子继承了父的所有类

比如：猫和狗都是动物（动物有吃，喝的方法），他们有相同属性，我们一个个定义太麻烦

代码解析:

class Father(object):# 父类
    print('全部财产')
    def interest(self):
        print('都是儿子的')
    pass
class Sun(Father):# 子类
    pass

Sun();#子类继承了父类
a=Sun();
a.interest();#子类继承了父类的方法
'''输出
全部财产
都是儿子的
'''

2.2 多继承

子类可以继承一个父类，那是否可以继承两个父类或多个呢？答案是肯定的，这就是python的多继承

代码解析:

# 一对多，多对一的关系

class Father1(object):
    def a(self):
        print('第一个父亲')
        pass
    def Repeat(self):
        print('这是第一个父亲的同名方法')
class Father2(object):
    def b(self):
        print('第二个父亲')
        pass
    def Repeat(self):
        print('这是第二个父亲的同名方法')
class sun(Father1,Father2):#一个儿子继承两个父亲
    pass
c=sun();#创建对象
c.a();# 调用父类方法
c.b();

# 如果同名调用哪个

c.Repeat();#输出结果是调用了第一个父亲的

# 我们可以通过__mro__函数查看解析顺序
print(sun.__mro__)
#(<class '__main__.sun'>, <class '__main__.Father1'>, <class '__main__.Father2'>, <class 'object'>)
'''输出
第一个父亲
第二个父亲
这是第一个父亲的同名方法
(<class '__main__.sun'>, <class '__main__.Father1'>, <class '__main__.Father2'>, <class 'object'>)
'''

2.3 继承传递和重写父类

# 继承传递就是爷爷给爸爸，爸爸给儿子

class GrandFather(object):
    def eat(self):
        print('吃饭')
        # 继承  GrandFather 类
class Father(GrandFather):
    def fight(self):
        print('爸爸是用脚打儿子')
    pass# 继承 Father类
class Son(Father):
    def fight(self):
        print('儿子不给爸爸打')
    pass
lg = Son()
lg.eat()#调用了爷爷吃的方法

# 重写父类方法
ll=Father();#创建父类对象
ll.fight();
lg.fight();#从写了父类figh方法
'''输出
吃饭
爸爸是用脚打儿子
儿子不给爸爸打
'''

2.4 调用父类方法

如果在子类中有一个方法需要父类的功能，并且又要添加新的功能。如果直接重写父类方法，那么就要重复写很多代码。那么这就要调用父类方法

class Father(object):
    def __init__(self,name):
        self.name=name
        pass
class sun(Father):
    def __init__(self,name):#重新构建父类方法
        #第一种
        super(sun, self).__init__(name)
        # 第二种方法
        #super().__init__(name)
        # 第三种方法
        #Father.__init__(self,name)
        # 添加新的功能
        self.name+='你好'
        print(self.name)
a=sun('dog')

三. 多态

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。后面统一调用

# 案例演示
class Animal:
    '''
    父类【基类】
    '''
    def say_who(self):
        print('我是一个动物....')
        pass
    pass
class Duck(Animal):
    '''
      鸭子类 【子类】 派生类
    '''
    def say_who(self):
        '''
        在这里重写父类的方法
        :return:
        '''
        print('我是一只漂亮的鸭子')
        pass
    pass
class People:
    def say_who(self):
        print('我是人类')
    pass

class student(People):
    def say_who(self):
        print('我是一年级的学习 张明')
    pass
#定义一个调用方法
def commonInvoke(obj):
    '''
        统一调用的方法
        :param obj: 对象的实例
        :return:
        '''
    obj.say_who()
    pass
listA=[Duck(),student()]#定义一个列表存放子类
for item in listA:#遍历列表,循环调用函数，输出say_who()
    commonInvoke(item)
'''输出
我是一只漂亮的鸭子
我是一年级的学习 张明
'''

四. 类属性和实例属性

1. 类属性 :就是类对象所拥有的属性,是可以被类对象和实例对象共同访问使用的
2. 实例属性:只能由实例对象所访问

# 属性：类属性和实例属性

class Test(object):
    Ch='python'#类属性
    def __init__(self,name):
        self.name=name#实例属性
        pass
test=Test('love')#创建实例对象
print(test.Ch)#可以访问类属性
print(Test.Ch)#可以访问
#print(Test.name)#类对象不可以访问实例属性
print(test.name)#实例对象可以访问实例属性
#test.Ch='刘德华'  #通过实例对象 对类属性进行修改 可以吗? 不可以的，
#print(Test.Ch)类属性没有更改

#可是通过类对象对实例对象进行修改就可以，这相当于一个等级，先类才能到方法

'''输出
python
python
love
'''

五. 类方法和静态方法

1. 类方法：类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数，类方法可以通过类对象，实例对象调用
2. 对比：

（1）类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法

（2）实例方法的第一个参数是实例对象self，通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析)，不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。

（3）静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用。

class  People:
    country='china'
    #类方法 用 classmethod 来进行修饰
    @classmethod
    def get_country(cls):
        return cls.country #访问类属性
        pass
    @classmethod
    def change_country(cls,data):
        cls.country=data #修改类属性的值  在类方法中
        pass
    @staticmethod
    def getData():
        return People.country  #通过类对象去引用
        pass
    @staticmethod
    def add(x,y):
        return x+y
        pass


print(People.add(10,56)) #带有参数的静态方法

# print(People.getData())

# print(People.get_country()) #通过类对象去引用
p=People()
print(p.getData()) #注意 一般情况下 我们不会通过实例对象去访问静态方法
# print('实例对象访问 %s'%p.get_country())
# print('-----------------修改之后---------------------------')
# People.change_country('英国')
# print(People.get_country()) #通过类对象去引用

3. 为什么要使用静态方法呢

由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，也就是说，在静态方法中，不会涉及到类中方法和属性的操作数据资源能够得到有效的充分利用

# demo  返回当前的系统时间
import  time # 引入第三方的时间模块
class TimeTest:
    def __init__(self,hour,min,second):
        self.hour=hour
        self.min = min
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S",time.localtime())
        pass
    pass

print(TimeTest.showTime())
t=TimeTest(2,10,15)
print(t.showTime()) #没有必要通过这种方式去访问 静态方法

本人博客：https://blog.csdn.net/weixin_46654114
本人b站求关注：https://space.bilibili.com/391105864
转载说明：跟我说明，务必注明来源，附带本人博客连接。

请给我点个赞鼓励我吧