Python基础语法知识点汇总

Python学习笔记

1. 第一个phthon程序

print("Hello World!");

2. 基本语法知识

2.1 注释

# 单行注释内容

"""
多行注释内容
"""

print("注释的两种表示方法");

2.2 PhCharm中的提示信息

• 灰色波浪线：表示书写不规范
• 绿色波浪线：表示单词拼写可能存在问题
• 红色波浪线：语法检查

2.3 算术运算

除了和平时其他语言相同的+，-，*，%以外：

• / 表示除法（不取整）
• // 表示整除
• ** 表示次方运算

print(10 / 3);
print(10 // 3);
print(2 ** 4);

运算结果：

3.3333333333333335
3
16

其中，乘法的优先级最高，+和-的优先级最低，但是我们可以使用（）来提高运行的优先级及运算的顺序

2.4 变量

• 只能以数字，字母，下划线组成
• 不能以数字开头
• 不能是关键字
• 区分大小写

a = 10;   //直接定义变量
print(a);

变量的类型分为数值型和非数值型，其中：

数值型包括：int，float，bool等

非数值类型包括：str字符串等等

我们可以使用type(变量名)来获取该变量属于哪个类型

t = 10;
print(type(t));
t = 15.6;
print(type(t));
t = True;
print(type(t));
t = "tmx520";
print(type(t));

输出结果：

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'str'>

2.5 字符串的运算

• 与Java不同，字符串只能与字符串相连，不能与其他类型（例如：int类型）相连，即使用+相加
• 字符串可以使用*与数字相连，表示反复连接这个字符串

a = "feng";
print(a * 5);

输出结果：

fengfengfengfengfeng

2.6 标准输入

使用**input()**来接收用户输入的信息，当执行到input()操作的时候，程序就会等待用户输入，而不向下执行

两种方式：

# 方式1：不带提示信息
name = input();
print(name);

# 方式2：带有提示信息
name = input("请输入你的姓名：");
print(name)

测试：

feng
feng
请输入你的姓名：feng
feng

注意事项：

• 使用input操作得到的数据都是字符串str类型的
• 我们可以使用int()，float()来进行格式的转换，但是注意int类型可以转换成float类型，但是float类型无法转成int类型

2.7 格式化输出

语法格式：

• print（变量）
• print（“格式化字符串” % 变量）
• print（“格式化字符串” % （变量1，变量2，…，变量n））

其中，占位符：

占位符	作用
%s	字符串
%d	整数
%6d	整数，数字用于设置位数（最小值），不足补空白
%f	浮点数

案例：带输入输出求圆的面积

pi = 3.14;
r = float(input("请输入圆的半径："));
area = pi * r ** 2;
print("圆的面积为：%f" % area);

输出结果：

请输入圆的半径：3
圆的面积为：28.260000

2.8 字符串的比较运算

字符比较运算排序表：

• 0…数字…9 < A…大写字母…Z < a…小写字母…z

2.9 关系运算符

关系运算符分为and，or和not

其中，数字可以作为布尔表达式参与运算：

• 非0数字表示True
• 0表示False

2.10 条件语句

代码格式：

if 条件1:
    执行代码
else if 条件2:
    执行代码
else:
    执行代码

2.11 循环语句

代码格式：

for 变量名 in 数组/字符串/集合
	代码

测试用例：

# for循环打印1-10，其中range(n)表示生成0到n - 1的连续整数
for i in range(10):
    print(i + 1);

# 遍历打印str字符串的每一个字符
str = "abcdefg";
for ch in str:
    print(ch);

while循环代码格式:

while 条件:
    循环内部代码块

2.12 函数

函数的定义：

def 函数名():
    函数体

注意：函数的调用必须在函数定义之后！！！

在pyCharm可以使用F8直接执行大步骤，F7进入内部小步骤…

2.13 函数文档注释

我们在函数中使用多行注释，进行函数内容的说明

2.14 带参数的函数

def 函数名(参数):
    函数体内容
调用函数时直接使用: 函数名(参数)

2.15 函数变量的作用域

• 局部变量：函数内部定义的变量从定义位置开始到函数定义结束位置有效

• 全局变量：函数外部定义的变量在整个文件中有效

• 函数间不能共享内部定义的变量

• 函数内部可以使用全局变量

• 注意：如果局部变量与全局变量发生冲突，我们可以使用global关键字来将局部变量提升为全局变量，但是需要先声明再使用

2.16 函数定义----带有返回值

def 函数名(参数列表):
	函数体
    # 直接在这里添加返回值语句即可
    return 函数需要返回的值

2.17 案例：求三个数的最大值

# 输入三个数
x = int(input("请输入数字x:"));
y = int(input("请输入数字y:"));
z = int(input("请输入数字z:"));


# 求两个数的最大值的函数max
def max(a,b):
    if a >= b:
        return a;
    else:
        return b;

max = max(max(x,y),z);
print("x,y,z的最大值为: %d" %max);

3. 面向对象

3.1 类的定义

定义格式1：

class 类名:
	pass    

定义格式2：

class 类名:
    成员

其中，在格式1中的pass表示该类为空类，什么都没有！！！

3.2 对象的创建格式

变量名 = 类名();

3.3 类的成员变量（经常使用！！！）

class 类名:
	def __init__(self):
        self.变量名1 = 值1;
        self.变量名2 = 值2;
        self.变量名3 = 值3;
        self.变量名4 = 值4;

或者我们可以直接声明变量：

• 如果此时声明的变量不存在则视为定义变量
• 如果变量名存在则视为调用变量

3.4 类的成员方法：其中的self和this类似

class 类名:
	def 方法名(self):
        方法体

其中，self仅仅表示声明时的占位，无需传递具体的参数

如果是带有形参的方法：

class 类名:
	def 方法名(self,形参1,形参2,...)
    	方法体

成员方法调用成员方法：直接访问，使用self进行

3.5 init方法与魔术方法

__init__方法在创建对象的时候被运行，无需手动调用即可执行…

对于程序中声明，定义的方法在特定时机自动执行的方法，我们称之为魔术方法，其中，魔术方法的特点是方法名的前后有两个下划线！

3.6 str方法

def __str(self):
    return "你需要显示的信息";

• str方法在使用print函数输出打印对象时被调用！！！

3.7 案例：手机案例

需求：

• 手机电量默认为100
• 打游戏每次消耗电量10
• 听歌每次消耗电量5
• 打电话消耗电量4
• 充电可以为手机补充电量为100

class Phone:
    def __init__(self):
        self.quantity = 100;

    def consume(self, x):
        self.quantity -= x;
    # 打游戏
    def playGame(self):
        print("正在打游戏...");
        self.consume(10);
        print("打完游戏剩余电量为: %d" %self.quantity);
    # 听歌
    def listenMusic(self):
        print("正在听歌...");
        self.consume(5);
        print("听完歌剩余电量为: %d" %self.quantity);
    # 打电话
    def call(self):
        print("正在打电话...");
        self.consume(4);
        print("打完电话剩余电量为: %d" %self.quantity);
    #充电
    def charge(self):
        print("正在充电...")
        self.consume(3);
        print("充电结束，电量百分之百")

myPhone = Phone();
myPhone.listenMusic();
myPhone.playGame();
myPhone.call();
print("此时手机剩余电量为" + str(myPhone.quantity));
myPhone.charge();

3.8 面向对象的封装特性

使用对成员变量私有化可以有效地保护从类的外部对类的内部成员进行访问

• 在定义变量是使用**___**表示

我们通过set和get方法进行私有变量的获取和值的设置

标准定义格式

对受保护的变量进行私有设置
self.__变量名 = 值
提功对外访问器
访问器(get方法):
def get_变量名(self):
    return self.__变量名;
访问器(set方法):
def set_变量名(self,形参):
    self.__变量名 = 形参;

代码举例：

class Person:
    def __init__(self):
        self.__name = "feng";
        self.__age = 18;
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name;
    def get_age(self):
        return self.__age;
    def set_age(self, age):
        self.__age = age;


p = Person();
print(str(p.get_name()) + str(p.get_age()));

输出结果：

feng18

**init方法带有参数：**上面的代码可以修改为

class Person:
    # 直接传入两个参数
    def __init__(self,name,age):
        self.__name = name;
        self.__age = age;
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name;
    def get_age(self):
        return self.__age;
    def set_age(self, age):
        self.__age = age;

此时创建对象的格式为：

变量名 = 类名(参数1,参数2,...)

3.9 类成员变量

类中的成员变量描述对象的属性值根据对象不同，会产生区别，称此类变量为实例变量

类中的成员变量描述对象的属性值根据对象不同，不会产生区别，称此类变量为类变量

类变量是归属类的，实例变量是归属对象的。

类成员变量的定义方式：

class 类名:
    变量名 = 值

调用格式：

赋值:
    类名.变量名 = 值
取值:
    类名.变量名

注意：

• 类变量不允许使用对象名进行调用修改，只能通过类名进行修改，如果我们使拥对象进行修改类变量则是创建了新的对象变量
• 类变量可以进行私有化

3.10 类方法

class 类名:
    @classmethod
    def 方法名(cls,形参列表):
        方法体

调用格式：

类名.方法名(实参列表)

注意事项：

• 类方法中不允许使拥实例变量和实例方法

• 实例方法中允许使用类变量和类方法

• 其中实例方法中self和类方法中的cls只是一个名称罢了，并没有过多的意义

3.11 静态方法

class 类名:
	@staticmethod
    def 方法名(形参列表):
        	方法体

调用格式：

• 类名.方法名(实参参数)或者对象名.方法名(实参参数)

其中，静态方法与类无关，可以将其转换成函数直接使用

3.12 面向对象的变量总结

全局变量：直接定义在py文件中，或者我们在一个类中，使用global声明的变量，则其为全局变量

**局部变量：**在方法中直接定义（没有使用self修饰的）为局部变量

公有变量：在init方法或者其他成员方法中使用self.进行定义的变量称为公有变量

独有变量：在我们的类中没有进行声明定义，在外部程序中添加了一个变量属性，称之为独有变量

私有变量：类的变量前使用**__**进行声明和定义

类变量：在类中直接定义的变量

举例说明：

class User:
    country = "类变量"
    __title = "类变量，私有变量"


    def __init__(self):
        self.name = "公有变量"
        self.__age = "公有变量，私有变量"
        info = "局部变量"

    def test(self):
        self.address = "公有变量"
        email = "局部变量"

city = "全局变量"
info = "全局变量"


u = User()
u.gender = "独有变量"

其中，使用变量的频率：公有变量 > 局部变量 > 私有变量，并且我们的公有变量 == 成员变量

3.12 面向对象的继承特性

定义格式：

class 类名(父类名):
    pass

注意：

• 子类可以添加父类没有的成员
• 父类的私有成员不可以被继承

如果我们想要知道此时我们的类的继承的关系，可以使用**mro**方法来显示出其类的继承关系

class Animal:
    pass


class Cat(Animal):
    pass


class RedCat(Cat):
    pass


print(RedCat.__mro__)

输出结果：

(<class '__main__.RedCat'>, <class '__main__.Cat'>, <class '__main__.Animal'>, <class 'object'>)

其中，我们的object类是所有类的父类

方法的重写：

• 在继承关系基础上，子类重写父类的已经存在的不私有的方法

• 如果子类重写了父类的方法，使用子类对象调用被重写的方法的时候，执行子类重写后的方法

class Person:
    def identify(self):
        print("I am a person")
class Man(Person):
    def identify(self):
        print("I am a Man")
m = Man()
m.identify();

如果此时在子类重写父类的方法中，我们还想调用父类的方法，此时有以下几种方式：

调用方式1:
    父类名.方法名(对象)
调用方式2:
    super(本类名.对象).方法名()
调用方式3:
    super().方法名()

class Person:
    def identify(self):
        print("I am a person")
class Man(Person):
    def identify(self):
        super().identify()
        print("I am a Man")
m = Man()
m.identify();

此时输出结果：

I am a person
I am a Man

多继承（在Python中是支持的！！）

定义格式：

class 类名(父类1,父类2,....)

如果此时多个父类中出现相同的方法，此时就会冲突了，它会默认调用继承前面的方法！！！

举例：

class Father:
    def play(self):
        print("爸爸唱歌")


class Mother:
    def play(self):
        print("妈妈跳舞")


class Son(Father,Mother):
    pass


s = Son()
s.play();

此时输出打印调用的是Father类的play方法，如果你想调用Mother的play方法：

• 在继承关系中将Mother类写在前面，但是不方便
• 重写方法中，使用上面的第一种方式，手动地指定调用Mother的方法

3.13 面向对象的多态特性

• 一个对象具有多种形态，在不同的使用环境中以不同的形态展示其功能，称其对象具有多态特征。

• 多态发生在继承的基础之上

举例说明：

class Person:
    def work(self):
        print("人的工作是生活")


class Teacher(Person):
    def work(self):
        print("老师上课传授知识")


class Driver(Person):
    def work(self):
        print("司机开车载人")


# 传入person对象
def work(person):
    person.work()


# 传入teacher对象，执行其对应的work方法
teacher = Teacher()
work(teacher)
# 传入driver对象，执行其对应的work方法
driver = Driver()
work(driver)

输出结果：

老师上课传授知识
司机开车载人

鸭子类型

对象在语法层面满足调用关系，实际不具有对应的对象形态，称该对象此时具有鸭子类型

举例说明：

class Teacher:
    def teach(self):
        print("传授知识")



def study(teacher):
    teacher.teach()

teacher = Teacher()
study(teacher)

3.14 面向对象案例：反恐精英案例

案例要求：

• 设置三个恐怖分子与反恐精英接头枪战，每个人设置100点生命值，生命值为0则视为死亡，一方全部死亡则枪战结束
• 反恐精英通过个人状态值来描述自己
  • 无伤：生命值 100
  • 轻伤：生命值 70 - 99
  • 重伤：生命值 1 - 69
  • 挂了： 生命值 0

"""
1. 定义人类：描述公共属性 life（生命值） name（名字）
2. 定义出精英和恐怖分子类
3. 定义主函数描述枪战过程
4. 定义开枪的方法
"""
import random
class Person:
    def __init__(self,name):
        self.name = name
        self.life = 100     #初始生命值为100
    def __str__(self):
        status = ""
        if self.life <= 0:
            status = "挂了"
        elif self.life < 70:
            status = "重伤"
        elif self.life < 100:
            status = "轻伤"
        else:
            status = "无伤"
        return "%s 当前状态为： %s" %(self.name,status)


# 精英
class Hero(Person):
    def fire(self,p):
        damage = 40
        print("%s 向 %s 开枪，造成 %d 伤害" %(self.name,p.name,damage))
        p.life -= damage
        if p.life < 0:
            p.life = 0
    pass

# 恐怖分子
class Is(Person):
    def fire(self,p):
        damage = 10
        print("%s 向 %s 开枪，造成 %d 伤害" %(self.name,p.name,damage))
        p.life -= damage
        if p.life < 0:
            p.life = 0
    pass





"""
游戏规则，三个恐怖分子与反恐精英进行轮流决斗
如果反恐精英挂了，则恐怖分子胜利
如果三个恐怖分子都挂了，则反恐精英胜利
"""
def main():
    hero = Hero("【反恐精英】")
    is1 = Is("【恐怖分子1】")
    is2 = Is("【恐怖分子2】")
    is3 = Is("【恐怖分子3】")
    # 表示轮次
    index = 1
    while hero.life > 0 and (is1.life > 0 or is2.life > 0 or is3.life > 0):
        # 从(0 - 3中随机获取一个数字)
        num = random.randint(0, 3)
        print("第%d轮枪战开始：" %index)
        index += 1
        if num == 0:
            hero.fire(is1)
            hero.fire(is2)
            hero.fire(is3)
        elif num == 1:
            hero.fire(is1)
            is1.fire(hero)
        elif num == 2:
            hero.fire(is2)
            is2.fire(hero)
        elif num == 3:
            hero.fire(is3)
            is3.fire(hero)
        #输出精英和恐怖分子的状态
        print(hero.__str__())
        print(is1.__str__())
        print(is2.__str__())
        print(is3.__str__())
        print()

    if hero.life == 0:
        print("【恐怖分子】在第%d轮枪战中获胜" %index)
    else:
        print("%s在第%d轮枪战中获胜" %(hero.name,index))
#调用main()方法
main()

输出结果：

第1轮枪战开始：
【反恐精英】 向 【恐怖分子2】 开枪，造成 40 伤害
【恐怖分子2】 向 【反恐精英】 开枪，造成 10 伤害
【反恐精英】 当前状态为： 轻伤
【恐怖分子1】 当前状态为： 无伤
【恐怖分子2】 当前状态为： 重伤
【恐怖分子3】 当前状态为： 无伤

第2轮枪战开始：
【反恐精英】 向 【恐怖分子1】 开枪，造成 40 伤害
【恐怖分子1】 向 【反恐精英】 开枪，造成 10 伤害
【反恐精英】 当前状态为： 轻伤
【恐怖分子1】 当前状态为： 重伤
【恐怖分子2】 当前状态为： 重伤
【恐怖分子3】 当前状态为： 无伤

第3轮枪战开始：
【反恐精英】 向 【恐怖分子1】 开枪，造成 40 伤害
【恐怖分子1】 向 【反恐精英】 开枪，造成 10 伤害
【反恐精英】 当前状态为： 轻伤
【恐怖分子1】 当前状态为： 重伤
【恐怖分子2】 当前状态为： 重伤
【恐怖分子3】 当前状态为： 无伤

第4轮枪战开始：
【反恐精英】 向 【恐怖分子1】 开枪，造成 40 伤害
【恐怖分子1】 向 【反恐精英】 开枪，造成 10 伤害
【反恐精英】 当前状态为： 重伤
【恐怖分子1】 当前状态为： 挂了
【恐怖分子2】 当前状态为： 重伤
【恐怖分子3】 当前状态为： 无伤

第5轮枪战开始：
【反恐精英】 向 【恐怖分子2】 开枪，造成 40 伤害
【恐怖分子2】 向 【反恐精英】 开枪，造成 10 伤害
【反恐精英】 当前状态为： 重伤
【恐怖分子1】 当前状态为： 挂了
【恐怖分子2】 当前状态为： 重伤
【恐怖分子3】 当前状态为： 无伤

第6轮枪战开始：
【反恐精英】 向 【恐怖分子1】 开枪，造成 40 伤害
【恐怖分子1】 向 【反恐精英】 开枪，造成 10 伤害
【反恐精英】 当前状态为： 重伤
【恐怖分子1】 当前状态为： 挂了
【恐怖分子2】 当前状态为： 重伤
【恐怖分子3】 当前状态为： 无伤

第7轮枪战开始：
【反恐精英】 向 【恐怖分子3】 开枪，造成 40 伤害
【恐怖分子3】 向 【反恐精英】 开枪，造成 10 伤害
【反恐精英】 当前状态为： 重伤
【恐怖分子1】 当前状态为： 挂了
【恐怖分子2】 当前状态为： 重伤
【恐怖分子3】 当前状态为： 重伤

第8轮枪战开始：
【反恐精英】 向 【恐怖分子1】 开枪，造成 40 伤害
【反恐精英】 向 【恐怖分子2】 开枪，造成 40 伤害
【反恐精英】 向 【恐怖分子3】 开枪，造成 40 伤害
【反恐精英】 当前状态为： 重伤
【恐怖分子1】 当前状态为： 挂了
【恐怖分子2】 当前状态为： 挂了
【恐怖分子3】 当前状态为： 重伤

第9轮枪战开始：
【反恐精英】 向 【恐怖分子1】 开枪，造成 40 伤害
【反恐精英】 向 【恐怖分子2】 开枪，造成 40 伤害
【反恐精英】 向 【恐怖分子3】 开枪，造成 40 伤害
【反恐精英】 当前状态为： 重伤
【恐怖分子1】 当前状态为： 挂了
【恐怖分子2】 当前状态为： 挂了
【恐怖分子3】 当前状态为： 挂了

【反恐精英】在第10轮枪战中获胜

后续更新python的高级语法知识以及一些常见的实战项目笔记汇总，敬请期待…