python基础

出使python国

创建项目(windows)

python模板设置

print

代码案例

print(3)
# 浮点数
print(3.5)
# 表达式
print(3*4+2)
# 字符串
print("Helloword")
# 将数据输出到文件当中 1.文件路径 2.file指定文件名称
fp=open('c:/test.txt','a+')
print('hello',file=fp)
fp.close()
# 不换行输出
print('hello','word','python')

print('aa',end="")
print('bb')

转义字符

代码案例

print("Hello\nword")  #换行
print('Hello\tword')  #制表 匹配4bit
print('helloooo\tword') #制表 匹配4bit
print('hello\bword')  #退一个字符 backspace
print('hello\rword')  #退回行首部
print('http:\\\\baidu.com')   #转义 \
print('老师说：\'大家好\'')   # 转义'

#原字符，不希望字符串中的转义字符起作用，就是原字符，就是在字符串之前加上r或R

二进制

二进制与字符编码

unicode是一张表，规定了哪一个字符去使用哪一个数字表示

python中的标识符和保留字

import keyword
print(keyword.kwlist)
print(len(keyword.kwlist))

python中的变量和数据类型

变量就是内存中带标签的盒子
变量的三部分组成：标识、类型、值

name='李飞'
print('id:',id(name))
print('type:',type(name))
print('value:',name)

当多次赋值之后，变量会指向新的空间

数据类型

常用的数据类型

• 整数型->int
• 浮点型->float
• 字符串型->str
• 布尔型->bool

整数型

print(a,type(a))
n1=1.1
n2=2.2
print(n1+n2)

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))

数据类型转换

为什么需要数据类型转换：将不同类型的数据拼接在一起

name='李飞'
age=33
print('我叫'+name+'今年'+str(age))

python中的注释

单行注释

多行注释 没有单纯标记，三引号之间叫多行注释

中文编码声明注释

在文件的开头加上中文声明注释，用以指定源码文件的编码格式

算你赢

输入函数input

• 作用
• 返回值类型
• 存储到变量
  接收到的变量都为str类型

运算符

算术运算符

1. 标准运算符 + - * / %

>>> 1/2
0.5
>>> 11/2
5.5
>>> 11//2
5

2. 取余运算符
3. 幂运算符

赋值运算符

执行顺序：右->左
支持链式赋值：a=b=c=20
支持多参数赋值：+= -= *= /= %= //-
支持系列解包赋值：a,b,c=10,20,30

比较运算符 变量比较的值，列表比较的是id

布尔运算符

and or not in

位运算符

• &
• |
• <<

运算符的优先级

往哪走呢

程序的组织结构

顺序结构

对象的布尔值

分支结构

单分支if语句

双分支if...else语句

多分支if...elif...else语句

if语句的嵌套

条件表达式

result="haha" if 3<4 else "ok"

pass空语句

全民来找茬

bug的由来及分类

不同异常类的处理方式

a=10
b=0
try:
    result=a/b
    print(result)
except ZeroDivisionError:
    print("除数不能为0")

异常处理机制

常见的异常类型

tracertback 模块打印

pycharm调试模式

找对象不积极思想有问题

两大编程思想

类与对象的创建

类与对象

类是多个类似事物组成的群体的统称。能够帮我们快速理解和判断事物的性质。
不同的数据类型属于不同的类
使用内置函数可以查看数据类型
对象：类之下包含的相似的不同个例，也称实例
python中一切皆对象

类的创建

在类之内定义的函数称为方法

class Student:  #类名 由一个或多个字母组成，要求首字母大写，其余小写
    native_place='山西'   #直接写在类里的变量，称为类属性
    # 初始化方法
    def __init__(self,name,age):
        self.name=name    #实例属性，进行了一个赋值操作
        self.age=age      #实例属性
        print(self.name,self.age)
    # 实例方法
    def eat(self):   #在类之内定义的称为方法，在类之外定义的称为方法
        print("学生在吃饭")
    # 静态方法
    @staticmethod
    def method():
        print("我使用了staticmethod方法进行了修饰，所以我是静态方法")

    # 类方法
    @classmethod
    def cm(cls):
        print("我使用了classmethod方法进行了修饰，所有我是类方法")


def drink():
    print("喝水")



if __name__ == '__main__':
    # print(Student.native_place)
    # Student.eat('')
    # Student.method()
    # Student.cm()
    # drink()
    stu=Student('lifei','35')
    stu.method()
    stu.eat()    对象名.方法名
    stu.cm()
    Student.eat(stu)  #类名.方法名(对象)  
# 方法的调用有两种方式： 对象名.方法名和类名.方法名(对象)  

类属性，类方法，静态方法

类对象与类属性

类方法与静态方法

接着找对象

封装

提高程序的安全性

• 将数据属性和行为(方法)包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样无需关心方法内部的具体实现细节，从而隔离了复杂度
• 在python没有专门的修饰符用于属性的私有，如果该属性不希望在类对象的外部被访问，前面使用两个"_"。

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=str(age)
    def show(self):
        print(self.name+'\'s age is '+self.__age)
stu1=Student('zhangsan',20)
stu1.show()
stu1.name
print(dir(stu1))
print(stu1._Student__age)      #私有属性访问方式，不建议访问

继承

提高代码的复用性
python支持多继承
定义子类时，必须在其构造函数中调用父类的构造函数

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print('姓名：{0}，年龄：{1}'.format(self.name,self.age))
class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score=score
    def info(self):
        
        print('姓名:{0},得分:{1}'.format(self.name,self.score))

class Techer(Person):
    def __init__(self,name,age,teachofyear):

        super().__init__(name,age)
        self.teachofyear=teachofyear
    def info(self):
        super(Techer, self).info()


if __name__ == '__main__':
    person=Student('李飞',38,98)
    person.info()
    tech1=Techer('常江',31,5)
    tech1.info()

多继承

方法重写

• 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其(方法体)或属性进行重新编写
• 子类重写后的方法可以通过super().xxx()调用父类中被重写的方法

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print('姓名：{0}，年龄：{1}'.format(self.name,self.age))
class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score=score
    def info(self):
        
        print('姓名:{0},得分:{1}'.format(self.name,self.score))

class Techer(Person):
    def __init__(self,name,age,teachofyear):

        super().__init__(name,age)        
        self.teachofyear=teachofyear
    def info(self):
        super(Techer, self).info()     #方法重写
        print('姓名:{0},教龄:{1}'.format(self.name,self.teachofyear))

object类

• object类是所有类的父类，因此所有类都有object类的属性和方法
• 内置函数dir()可以查看指定对象的所有特性
• object有一个object.str()的方法，用于返回一个对于"对象的描述"，对应于内置函数str()经常用于print()的方法，帮我们查看对象的信息，我们经常会对__str__()进行重写

多态

提高程序的可扩展性和维护性

简单来说，多态就是"具有多种形态"，它指的是即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用的对象的类型，动态决定调用哪个对象中的方法

静态语言(java)和动态语言(python)关于多态的区别

1. 静态语言实现多态的三个必要条件：继承、方法重写、父类引用指向子类对象
2. 动态语言的多态崇尚"鸭子类型"当看到一只鸟走起来像鸭子、游起泳来像鸭子、收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中不需要对象是什么类型，到底是不是鸭子，只关心对像的行为。

特殊的属性和方法

class A():
    pass
class B():
    pass
class C(B,A):
    def __init__(self,name,age):
        self.name=name
        self.age=age

# 创建C类对象
x=C('Jack',20)
print(C.__dict__)
print(x.__dict__)  #实例对象的属性字典
print('--------------------------------------')
print(x.__class__)
print(C.__base__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())
print(object.__subclasses__())

class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self, other):
        return self.name+other.name
    def __len__(self):
        return len(self.name)

stu1=Student('zhangsan')
stu2=Student('lisi')
print(stu1.name)
print(stu2.name)
stu=stu1+stu2   #实现了两个对象的加法计算，因为在Student类中编写了add 特殊的方法.等同于下列命令 stu=stu1.__add__(stu2)
print(stu)
print(len(stu1))

class Person(object):
    def __new__(cls, *args, **kwargs):
        print('__new__被调用了,cls的id值为{0}'.format(id(cls)))

        obj=super().__new__(cls)
        print('创建对象的id{0}'.format(id(obj)))
        return obj
    def __init__(self,name,age):
        print('__init__被调用了，self的id值为{0}'.format(id(self)))
        self.name=name
        self.age=age
print('obj这个类的对象id为{0}'.format(id(object)))
print('Person这个类的对象id为{0}'.format(id(Person)))
p1=Person('张三',20)
print('p1这个Person类实例对象的id为{0}'.format(id(p1)))

以上代码执行的结果为

C:\lifei\pycharm\vippython\venv\Scripts\python.exe C:/lifei/pycharm/vippython/chap13/demo10.py
obj这个类的对象id为140703769794432
Person这个类的对象id为590662530320
__new__被调用了,cls的id值为590662530320
创建对象的id590663876272
__init__被调用了，self的id值为590663876272
p1这个Person类实例对象的id为590663876272

Process finished with exit code 0

类的赋值、浅拷贝和深拷贝

赋值

变量的赋值操作只是：只是两个变量，实际还是只像同一个对象

浅拷贝

浅拷贝：python的拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象和烤贝对角会引用同一个子对象

深拷贝

深拷贝：使用copy模块的deepcopy函数，递归拷贝包含对象中包含的子对象，源对象和烤贝对象所有子对象也不相同。

模块

什么叫模块

在python中一个扩展名为.py的文件 就是一个模块 。
在模块当中可以包含n多个函数、类、语句 。
一个项目里面可能有n多个模块。
n多个模块 最终组成 python 程序

使用模块的好处

• 方便其他程序和脚本的导入并使用
• 避免函数名和变量名冲突
• 提高代码的可维护性
• 提高代码的可重用性

导入模块

import 模块名 
import 模块名 as 别名
from 模块名 import 函数/变量/类 
from 模块名 import 函数/变量/类 as 别名

以主程序的形式运行程序

在每个模块的定义中都包含一个记录模块名称的变量__name__,程序可以检查该变量，以确定他们在模块模块中执行。如果一个模块不是被导入到其他程序中执行，那么他可能在解释器的顶级模块中执行。顶级模块的__name__变量值为'main'

if __name__=='__main__':
    pass

python中的包

包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下

作用：

• 代码规划
• 避免模块名称冲突

包和目录的区别

• 包含__init__.py文件的目录称为包
• 目录里通常不包含__init__文件

包的导入

import 包名.模块名