Python语法速查2

前一篇：Python语法速查1

8、数据类型

8.1、字符串

在python中，可以使用引号( ’ 或 " )来创建字符串
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

字符串截取

var1 = 'Hello World!'
var2 = "Runoob"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

输出结果

var1[0]:  H
var2[1:5]:  unoo

字符串更新

var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'Runoob!')

输出结果：

已更新字符串 :  Hello Runoob!

字符串运算符

a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

输出结果：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

格式化字符串
将一个值插入到一个有字符串格式符 %s 的字符串中。

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

输出结果：

我叫 小明 今年 10 岁!

参考资料：https://www.runoob.com/python3/python3-string.html

8.2、数值

整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。

浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

类型转换
int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

数值运算
在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //

>>> 17 / 3  # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 17 % 3  # ％操作符返回除法的余数
2
>>> 5 * 3 + 2 
17

需要注意的是，//运算符的结果对于计算的两个数的类型相关

>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0

不同类型的数混合运算时会将整数转换为浮点数：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

数学函数

随机数函数

三角函数

数学常量
PI
e

参考资料：https://www.runoob.com/python3/python3-number.html

9、面向对象编程

9.1、类：

类可以用来创建新的用户定义的数据结构，其中包含有关内容的任意信息。对于动物，我们可以创建一个Animal( )类来跟踪关于Animal的属性，如名称和年龄。

注意, 一个类只提供结构 - 它是应该如何定义某个东西的蓝图，但它实际上并不提供任何真实的内容. Animal( )类可以指定名称和年龄, 是定义动物所必需的，但它实际上不会包含特定动物的名字或年龄。

所有类都需要创建对象，所有对象都包含称为属性的特征（在开头段落中称为属性）。使用__init __（）方法通过为对象的初始属性提供其默认值（或状态）来初始化（例如，指定）对象的初始属性。此方法必须至少有一个参数以及自变量，它引用对象本身（例如，Dog）。

需要注意的是，self并不是py的关键字，只是按照惯例，我们使用该命名。
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称

class Dog:

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

无需主动调用__init __（）方法;当你创建一个新的’Dog’实例时会自动调用它。

9.2、实例：

如果说类是一个表格或问卷。它定义了所需的信息。填写表格后，您的特定副本就是该类的一个实例;它包含与您相关的实际信息。

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

class Cat():
    """模拟猫   类"""
    #类的初始化，必须要有self
    def __init__(self,name ,age):
        self.name = name
        self.age = age
        
#创建一个实例（我的猫叫mimi，1岁）
my_cat=Cat('mimi',1)
#调用这个类的元素
print("My cat name is: "+my_cat.name+". It is:"+str(my_cat.age)+" years old")

输出结果：

My cat name is: mimi. It is:1 years old

9.3、方法：

实例方法在类中定义，用于获取实例的内容。
它们还可用于使用对象的属性执行操作。与__init__方法一样，第一个参数始终是self：

class Cat():
    """模拟猫类"""
    #类的初始化，必须要有self
    def __init__(self,name ,age):
        self.name = name
        self.age = age

    def sit(self):#方法
        """给命令"""
        print(self.name.title()+" is now sitting.")


    def get_alldata(self):#该方法获取全部属性
        long_name=self.name+" "+str(self.age)
        return long_name #返回值
        
#创建一个实例（叫mimi，1岁）
my_cat=Cat('mimi',1)
my_cat.sit()

print("My cat name is: "+my_cat.name+". It is:"+str(my_cat.age)+" years old")

输出结果：

Mimi is now sitting.
My cat name is: mimi. It is:1 years old

9.4、属性：

以下列举两种属性，第一种为该类本身具有的共有属性，比如所有的狗都是哺乳动物，另一种为差异性属性，如年龄、名字等。
可以像以下的”物种=哺乳动物“一样，指定某个属性的默认值，或是在初始化方法中使用“self.kinds=“XX””进行赋值。两种方法均可实现完成指定属性默认值的功能。

class Dog:
	#物种：哺乳动物
	species = 'mammal'
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.kinds="XX"

需要注意的是，类中的形参和属性是两个东西

class Dog:
    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age1):
        self.name = name
        #此处使用self.age定义的是属性，age1是类的形参
        self.age = age1 
        self.kinds="XX"

如果需要修改属性，可以使用以下三种方式

1. 直接修改属性值：

class Dog:
    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.kinds="XX"
        
my_dog=Dog("Kitty",10)
my_dog.kinds="YY"
print(my_dog.kinds)

输出结果：YY

2. 通过方法进行修改：

class Dog:
    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.kinds="XX"
#定义一个方法，用于更新kinds属性
    def updata_kinds(self,kk):
        self.kinds=kk

my_dog=Dog("Kitty",10)
my_dog.updata_kinds("YY")
print(my_dog.kinds)

输出结果：YY

3. 通过方法对属性值进行递增：

class Dog:
    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age1):
        self.name = name
        self.age = age1
        self.kinds="XX"

    def updata_kinds(self,kk):
        self.kinds=kk
#对年龄进行累加输入数值
    def add_age(self,num):
        self.age+=num

my_dog=Dog("Kitty",2)
my_dog.add_age(1)
print(my_dog.age)

输出结果：3

9.5、继承：

继承是一个类采用另一个类的属性和方法的过程。新形成的类称为子类，子类派生的类称为父类。

重要的是要注意子类覆盖或扩展父类的功能（例如，属性和行为）。换句话说，子类继承了父项的所有属性和行为，但也可以添加不同行为。最基本的类是一个对象，通常所有其他类都继承为它们的父对象。

当子类继承父类后，就具有了父类的"属性"与"方法"，并且可以在此基础上添加子类新的属性与方法。

class Dog:

    # Class attribute
    species = 'mammal'

    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # instance method
    def description(self):
        return "{} is {} years old".format(self.name, self.age)

    # instance method
    def speak(self, sound):
        return "{} says {}".format(self.name, sound)


# Child class (inherits from Dog class)
class RussellTerrier(Dog):
    def run(self, speed):
        return "{} runs {}".format(self.name, speed)


# Child class (inherits from Dog class)
class Bulldog(Dog):
    def run(self, speed):
        return "{} runs {}".format(self.name, speed)


# Child classes inherit attributes and
# behaviors from the parent class
jim = Bulldog("Jim", 12)
print(jim.description())

# Child classes have specific attributes
# and behaviors as well
print(jim.run("slowly"))

输出结果：
“Jim is 12 years old”
“Jim runs slowly”

以下代码展示了使用super继承父类，可以参考：Python中super函数的用法

class Cat:
    """模拟猫类"""
    def __init__(self,name ,age):
        self.name = name
        self.age = age
    
    def sit(self):#方法
        """给命令"""
        print(self.name.title()+"is now sitting.")

    def roll_over(self):
        print(self.name.title()+"rolled over!")
    
    def get_alldata(self):#该方法获取全部属性
        long_name=self.name+" "+str(self.age)
        return long_name #返回值

    def color(self):
        return "black"


#继承父类
class Ocat(Cat):
    """橘猫也是猫"""
#    def __init__(self,name,age): #继承父类属性
#        super().__init__(name,age)#初始化父类属性
#        self.weight=1    #子类特有属性
    weight=1
    def get_catweight(self):
        print("weight is："+str(self.weight)+"Kg")
    #子类中同名的方法，覆盖父类对应的方法
    def color(self):
        return "Orange"

my_Ocat = Ocat('JM',10)
my_Ocat.weight=5
my_Ocat.sit()
print("test："+my_Ocat.get_alldata())
my_Ocat.get_catweight()

print(my_Ocat.color())

输出结果：

Jmis now sitting.
test：JM 10
weight is：5Kg
Orange

重写父类方法

#用子类对象调用父类被覆盖的方法
print(super(Ocat,my_Ocat).color())

输出结果:black

9.6、私有属性

使用两个下划线作为开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时如self.__private_attrs。

实例无法通过直接访问类属性的方式对私有属性进行访问，但是可以通过类的方法对私有属性进行访问与修改。
举个栗子：

class JustCounter:
    def __init__(self):
        self.__secretCount = 0  # 私有属性
        self.publicCount = 0    # 公开属性
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
 
counter = JustCounter()
counter.count()#运行两次,输出私有属性
counter.count()
print (counter.publicCount)#输出公有属性
#print (counter.__secretCount)  # 报错，实例不能直接访问私有属性

输出结果：
1
2
2

9.7、私有方法

与私有属性类似，实例无法对私有方法直接访问，但类中的方法进行访问，如下例子。

class Si:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()

x=Si("li","www.baidu.com")
x.who()
x.foo()
x.__foo()

输出结果：

9.8、类的专有方法（留坑）

init : 构造函数，在生成对象时调用
del : 析构函数，释放对象时使用
repr : 打印，转换
setitem : 按照索引赋值
getitem: 按照索引获取值
len: 获得长度
cmp: 比较运算
call: 函数调用
add: 加运算
sub: 减运算
mul: 乘运算
truediv: 除运算
mod: 求余运算
pow: 乘方

9.9、将其他类的实例作为属性

简单来说，如果某些大类的属性需要二次细分，就可以将属性再定义为一个小类，后在大类中新建的实例，就可以直接调用小类的方法和属性了。但是需要注意小类中的方法和初始值无法在新建的实例中修改。参考如下

我们定义了一个名为Battery的新类，它没有继承任何类。新类的方法__init__()除self外，还有另一个形参battery_size。这个形参是可选的：如果没有给它提供值，电瓶容量将被设置为70。方法describe_battery()也移到了这个类中。
在ElectricCar类中，我们添加了一个名为self.battery的属性。这行代码让Python创建一个新的Battery实例（由于没有指定尺寸，因此为默认值70），并将该实例存储在属性self.battery中。每当方法__init__()被调用时，都将执行该操作；因此现在每个ElectricCar实例都包含一个自动创建的Battery实例。

class Car():
   """一次模拟汽车的简单尝试"""
 
   def __init__(self, make, model, year):
       self.make = make
       self.model = model
       self.year = year
       self.odometer_reading = 0

   def get_descriptive_name(self):
       long_name = str(self.year) + " " + self.make + " "  + self.model
       return long_name

class Battery():
   """一次模拟汽车电池的简单尝试"""
   
   def __init__(self,battery_size):
       self.battery_size=battery_size

   def describe_battery(self):
       print("This car has a " + str(self.battery_size) + "-kwh battery.")

class ElectricCar(Car):
   """电动汽车的独特之处"""
 
   def __init__(self, make, model, year):
       super().__init__(make, model, year)
       self.battery = Battery(40)#将新建的类作为属性使用

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
#给类的属性赋值
my_tesla.battery_size=80
print(my_tesla.battery_size)
#新建实例直接对新建小类的属性赋值
my_tesla_bat=Battery(60)
print(my_tesla_bat.battery_size)
#调用小类的方法，打印输出（还是初始值）
my_tesla.battery.describe_battery()

输出结果：

2016 tesla model s
80
60
This car has a 40-kwh battery.

9.10、导入类

多文件编程思想，我们将.py称为模块，可以在不同模块中存储和调用不同的类

导入单个类
首先在car.py中新建一个Car类

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

    def get_descriptive_name(self):
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()

    def read_odometer(self):
        print("this car has "+str(self.odometer_reading)+" miles on it.")

    def update_odometer(self,mileage):
        if (mileage>=self.odometer_reading):
            self.odometer_reading=mileage

        else:
            print("You can't roll back an odometer!")
    
    def increment_odometer(self,miles):
        self.odometer_reading +=miles
        
 #继承父类       
class ElectricCar(Car):
    def __init__(self,make,model,year):

        super().__init__(make,model,year)

后我们对其进行调用

#从car.py文件引用Car类
from car import Car

my_new_car = Car('audi','a4',2017)
print(my_new_car.get_descriptive_name())

输出结果：“2017 Audi A4”

导入多个类
相较于导入单个类，我们需要使用继承的方式来实现多个类的导入，代码如下
我们依然使用上面代码中的car.py文件

#引入car模块
import car 

my_new_car = ElectricCar('audi','a4',2017)
print(my_new_car.get_descriptive_name())

输出结果：“2017 Audi A4”

9.11、模块与类

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

需要注意的是，在飞桨的Notebook中，如加入其他模块，需要对模块先进行运行，才能使其可被发现。新建模块点击编译器左侧文件夹、新建。

#运行car.py模块
%run car.py

其他操作可参考：https://aistudio.baidu.com/aistudio/projectdetail/1184156

除了上述介绍的方法外，我们还可以使用以下方法对其他模块的类进行调用

import car

my_new_car = ElectricCar('audi','a4',2017)
print(my_new_car.get_descriptive_name())

#调用car.py的Car类
my_old_car = car.Car('BYD','汉',2020)
print(my_old_car.get_descriptive_name())

输出结果：
2017 Audi A4
2020 Byd 汉

参考资料：https://www.runoob.com/python3/python3-class.html