20230402-Python学习里程碑-day1

Posted 2023-04-03 阴阳怪气

Python基础-变量与数据类型

4月2

安装python

注意：

1、勾选 ADD python to path （可以避免手动添加Path路径）

2、选择安装路径 （可以避免后续使用Pycharm时，配置解析器路径）

安装Pycharm

选择解析器：

默认安装完后，创建一个工程项目，创建xxx.py文件，你会发现 No Python interpreter configured for the project 黄色的提示，没有可用解析器，需要手动配置一下。路径就是安装Python的路径

1、找到设备解析器位置：打开Pycharm页面 file --> settings --> Project --> Project Interpreter

2、添加解析器：⚙图标 --> Add --> Existing environment --> Interpreter --> ... (选择自己安装Python的路径) --> OK确定

3、可以勾选：Make available to all projects （使用项目都使用这个解析器）

4、最后 点击 :OK (完成配置解析器)

Python和Pycharm的关系

比作一个的灵魂和躯壳：

Python 灵魂

Pycharm 躯壳

Pycharm 快捷键

ctrl + d	#复制光标所在的一行
ctrl + /	#多行注释（取消注释）
ctrl + alt + L	#格式代码

认识变量

举例体验：我们去图书馆读书，怎样能快速的找到自己想要的书籍呢？是不是管理员提前将书放到固定的位置，并把它这个位置进行编了号，我们只需要在图书馆中按照这个编号查询找到指定的位置就能找到想要的书籍。

这个编号其实就是存放书籍在书架中的位置起了一个名字，方便后期查询和使用

在程序中，数据都是临时存储在内存中，为了更快速的查找或使用这个数据，通常我们把这个数据在内存中存储之后定义一个名称，这个名称就是变量。

变量就是一个存储数据的时候，当前数据所在的内存地址的名字而已

赋值

定义变量

等于号 = 用来给别变量赋值

变量分为变量名 ，变量值， 内存地址

检测变量存储内存的地址：id()

C:\\Users\\25466>python

>>> name=\'yuwen\'

>>> name #变量为name，“yuwen”是值
\'yuwen\'

>>> id(name) 	#id查询name在内存中的地址
1932511545904

命名规范

内置函数不能使用

查询内置变量：导入keyword模块，在打印Python 中的关键字列表

标识符命名规则是Python中定义各种名字的时候的统⼀规范，具体如下：

规则：

• 由数字、字⺟、下划线组成

注意：

• 不能数字开头&纯数字
• 不能使⽤python内置关键字
• 不能用python类型

C:\\Users\\25466>python

>>> import keyword

>>> print (keyword.kwlist)
[\'False\', \'None\', \'True\', \'__peg_parser__\', \'and\', \'as\', \'assert\', \'async\', \'await\', \'break\', \'class\', \'continue\', \'def\', \'del\', \'elif\', \'else\', \'except\', \'finally\', \'for\', \'from\', \'global\', \'if\', \'import\', \'in\', \'is\', \'lambda\', \'nonlocal\', \'not\', \'or\', \'pass\', \'raise\', \'return\', \'try\', \'while\', \'with\', \'yield\']

>>>

严格区分大小写

>>> a=\'yuwen\'	#赋值变量a，值为’yuwen‘

>>> a
\'yuwen\'

>>> A		#没有A的变量
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name \'A\' is not defined

>>>

多变量赋值

Python允许同时为多个变量赋值

>>> a = b = c = \'yuwen\'

>>> a
\'yuwen\'

>>> b
\'yuwen\'

>>> c
\'yuwen\'

>>> id(a)
2912790385840

>>> id(b)
2912790385840

>>> id(c)
2912790385840  #会发现他们的在内存中的地址都是一样的

>>>

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。您也可以为多个对象指定多个变量

>>> a,b,c=1,2,3

>>> a
1

>>> b
2

>>> c
3

>>> id(a)
2912784050480

>>> id(b)
2912784050512

>>> id(c)
2912784050544

>>>

命名习惯：

驼峰命名法：

⼤驼峰：即每个单词⾸字⺟都⼤写，例如： MyName 。

⼩驼峰：第⼆个（含）以后的单词⾸字⺟⼤写，例如： myName 。

下划线：例如： my_name 。

使用变量

通过变量名去使用

>>>num_1 = 10     # 赋值整型变量

>>>cash = 100.0  # 浮点型

>>>name = "yuwen"   # 字符串

 # 输出结果

>>>num_1
100

>>>cash
1000.0

>>>name
"yuwen"

认识数据类型

在 Python ⾥为了应对不同的业务需求，也把数据分为不同的类型。

检测数据类型的方法：type()

a = 1
print(type(a))  # <class \'int\'> -- 整型

b = 1.1
print(type(b))  # <class \'float\'> -- 浮点型

c = True
print(type(c))  # <class \'bool\'> -- 布尔型

d = \'12345\'
print(type(d))  # <class \'str\'> -- 字符串

e = [10, 20, 30]
print(type(e))  # <class \'list\'> -- 列表

f = (10, 20, 30)
print(type(f))  # <class \'tuple\'> -- 元组

h = 10, 20, 30
print(type(h))  # <class \'set\'> -- 集合

g = \'name\': \'TOM\', \'age\': 20
print(type(g))  # <class \'dict\'> -- 字典

本文来自博客园，作者：xiao智，转载请注明原文链接：https://www.cnblogs.com/yuwen01/p/17281828.html

Day21

1、接口类和抽象类

抽象类和接口类

java 编程原则和设计模式

设计模式 程序设计 具有里程碑意义的设计方式 从java中演变出来的

　　单例模式

　　一个类只有一个实例

算法导论 计算的方法 时间和空间的问题 权威通用

java

　　面向对象

　　java不能多继承

编程原则

　　python

　　开放封闭原则

　　　　开放 对扩展是开放的

　　　　 封闭 对修改是封闭的

　　　依赖倒置原则

　　　接口隔离原则

已经写完的程序代码是不允许修改的

#支付功能的例子
    #支付宝支付
    #qq支付
    #apply_pay
    #微信支付

#创建一个规范
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类
    @abstractmethod
    def pay(self):pass  # 抽象方法

class Alipay(Payment):
    def pay(self,money):
        print(‘使用支付宝支付了%s元‘%money)

class QQpay(Payment):
    def pay(self,money):
        print(‘使用qq支付了%s元‘%money)

class Wechatpay(Payment):
    def pay(self,money):
        print(‘使用微信支付了%s元‘%money)
    def recharge(self):pass

def pay(a,money):
    a.pay(money)

a = Alipay()
a.pay(100)
pay(a,100)    # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
q = QQpay()
# q.pay(100)
pay(q,100)
w = Wechatpay()
pay(w,100)   # 到用的时候才会报错

　

抽象类和接口类做的事情 ：建立规范
制定一个类的metaclass是ABCMeta，
那么这个类就变成了一个抽象类(接口类)
这个类的主要功能就是建立一个规范

抽象类中所有被abstractmethod装饰的方法都必须被继承的子类实现
如果不实现，那么在实例化阶段将会报错

无论是抽象类还是接口类metaclass=ABCMeta 都不可以被实例化
p = Payment()  # 报错

　

#归一化设计
l = [1,2,2]
l2 = {1,2,3,4}
l3 = (1,2)
a = ‘1234567‘
print(len(l))
print(l3.__len__())
len()  和 __len__()
#只有一个类中实现了__len__()方法，才能使用len()函数
def len2(obj):  # 归一化设计
    return obj.__len__()

print(len(l))
print(len(l2))
print(len(l3))

 2、接口隔离原则

# 什么叫接口
# python里没有接口的概念
# 那接口是哪儿来的概念呢？
    # java类没有多继承 接口可以实现多继承
# 描述动物园
# 会游泳的 会走路的 会爬树的 会飞的
# 老虎
# 青蛙
# 天鹅
# 猴子
from abc import ABCMeta,abstractmethod
class FlyAnimal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):pass
    @abstractmethod
    def cal_flying_speed(self):pass
    @abstractmethod
    def cal_flying_height(self):pass
class WalkAnimal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass
class SwimAnimal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass
class Tiger(WalkAnimal,SwimAnimal):
    def walk(self):pass
    def swim(self):pass
class Monkey:
    def walk(self):pass
    def climb(self):pass
class Swan(FlyAnimal,WalkAnimal,SwimAnimal):
    def swim(self):pass
    def walk(self):pass
    def fly(self):pass
    def cal_flying_speed(self):pass
    def cal_flying_height(self):pass
class Parrot(FlyAnimal):
    def fly(self):pass
    def cal_flying_speed(self):pass
    def cal_flying_height(self): pass
# 所有会飞的动物 具有一些会飞的动物的特性
# 所有会走的动物 具有一些会走的动物的特性

View Code

接口类的作用：
在java中，能够满足接口隔离原则，且完成多继承的约束
而在python中，满足接口隔离原则，由于python本身支持多继承，所以就不需要接口的概念了

抽象类和接口类
在python中
并没有什么不同，都是用来约束子类中的方法的
只要是抽象类和接口类中被abstractmethod装饰的方法，都需要被子类实现
需要注意的是，当多个类之间有相同的功能也有不同的功能的时候，应该采用多个接口类来进行分别的约束

在java中
抽象类和接口截然不同
抽象类的本质还是一个类 是类就必须遵循单继承的规则，所以一个子类如果被抽象类约束，那么它只能被一个父类控制
当多个类之间有相同的功能也有不同的功能的时候 java只能用接口来解决问题

面试的时候
抽象类 是python中定义类的一种规范
接口
在公司类写代码的时候
如果遇到抽象类 记得按照抽象类中的规范一一实现对应的方法

3、多态

多态
java c++ c# —— 强类型语言
相同数据类型之间做运算
def func(int a):pass
func(‘a‘)

shell语言 —— 弱类型语言
1+‘1‘
def func(a):pass
1 ‘a‘ [1,2,3] ()

介于 强类型 与 弱类型之间 —— python 动态强类型语言
相同数据类型之间做运算
def func(a):pass

class Payment:
    def pay(self):pass

class QQpay(Payment):
    def pay(self,money):
        print(‘使用qq支付了%s元‘%money)

class Wechatpay(Payment):
    def pay(self,money):
        print(‘使用微信支付了%s元‘%money)
    def recharge(self):pass

# def pay(Payment pay_obj,int money):   #  java 多态 在一个类之下发展出来的多个类的对象都可以作为参数传入这里
#     pay_obj.pay(money)

View Code

无论是python的2.*还是3.*都天生自带多态效果

鸭子类型

class QQpay():
    def pay(self,money):
        print(‘使用qq支付了%s元‘%money)

class Wechatpay():
    def pay(self,money):
        print(‘使用微信支付了%s元‘%money)

def pay(pay_obj,money):
    pay_obj.pay(money)

多态和鸭子类型
多态 通过继承实现
java 在一个类之下发展出来的多个类的对象都可以作为参数传入一个函数或者方法
在python中不需要刻意实现多态，因为python本身自带多态效果
鸭子类型
不是通过具体的继承关系来约束某些类中必须有哪些方法名
是通过一种约定俗成的概念来保证在多个类中相似的功能叫相同的名字