python基础语法笔记

变量

Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。

标准数据类型

Python有六个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Boolean（布尔）

标识符

标识符由字母、下划线和数字组成，且数字不能开头

关键字

and     as      assert     break     class      continue    def     del
elif    else    except     exec      finally    for         from    global
if      in      import     is        lambda     not         or      pass
print   raise   return     try       while      with        yield

输出

常用的格式符号

下面是完整的，它可以与％符号使用列表:

格式符号	转换
%c	字符
%s	字符串
%d	有符号十进制整数
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写字母0x）
%X	十六进制整数（大写字母0X）
%f	浮点数
%e	科学计数法（小写’e’）
%E	科学计数法（大写“E”）
%g	％f和％e 的简写
%G	％f和％E的简写

输入

• input()的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个简单提示
• input()在从键盘获取了数据以后，会存放到等号右边的变量中
• input()会把用户输入的任何值都作为字符串来对待

运算符

算数运算符

下面以a=15 ,b=10为例进行计算

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 25
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 5
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 150
/	除	b / a 输出结果 1.5
//	取整除	返回商的整数部分 15//10 输出结果 1 , 15.0//10 输出结果 1.0
%	取余	返回除法的余数 b % a 输出结果 5
**	指数	a**b 为15的10次方， 输出结果 576650390625

比较运算符

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3，则（a == b) 为 True
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3，则(a != b) 为 True
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3，则(a > b) 为 True
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3，则(a < b) 为 False
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3，则(a >= b) 为 True
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3，则(a <= b) 为 True

逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。	True and False， 返回 False。
or	x or y	布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。	False or True， 返回 True。
not	not x	布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not True 返回 False, not False 返回 True

常用的数据类型转换

函数	说明
int(x [,base ])	将x转换为一个整数
float(x )	将x转换为一个浮点数
complex(real [,imag ])	创建一个复数，real为实部，imag为虚部
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表
chr(x )	将一个整数转换为一个Unicode字符
ord(x )	将一个字符转换为它的ASCII整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串
bin(x )	将一个整数转换为一个二进制字符串

条件判断

if 要判断的条件1:
	条件成立时，要做的事情
elif 要判断的条件2:
    条件成立时，要做的事情
else:
    否则，要做的事情

a if a > b else b

如果 a > b的条件成立,三目运算的结果是a,否则就是b

循环语句

while循环

while 条件:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...

for循环

for 临时变量 in 列表或者字符串等可迭代对象:
    循环满足条件时执行的代码

容器：字符串、列表、元组、字典

字符串

f-strings 提供一种简洁易读的方式, 可以在字符串中包含 Python 表达式. f-strings 以字母 ‘f’ 或 ‘F’ 为前缀, 格式化字符串使用一对单引号、双引号、三单引号、三双引号.

类似EL表达式

字符串实际上就是字符的数组，所以支持下标索引

切片：

切片的语法：[起始:结束:步长]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

常见方法：

• find（）：检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
• index（）：跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
• count（）：返回 str在start和end之间 在 mystr里面出现的次数
• replace（）：把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
• split（）：以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit+1 个子字符串
• join（）：将 mystr 插入到 str 中每个元素之间,构造出一个新的字符串

其余常用方法：

• capitaliz（）：把字符串的第一个字符大写
• title（）：把字符串的每个单词首字母大写
• startwith（）：检查字符串是否是以 hello 开头, 是则返回 True，否则返回 False
• endswith（）：检查字符串是否以obj结束，如果是返回True,否则返回 False.
• lower（）：转换 mystr 中所有大写字符为小写
• upper（）：转换 mystr 中所有大写字符为小写
• ljust（）：返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
• rjust（）：返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
• center（）：返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
• lstrip（）：删除 mystr 左边的空白字符
• rstrip（）：删除 mystr 字符串末尾的空白字符
• strip（）：删除mystr字符串两端的空白字符
• rfind（）：类似于 find()函数，不过是从右边开始查找.
• rindex（）：类似于 index()，不过是从右边开始.
• partition（）：把mystr以str分割成三部分,str前，str和str后
• rpartition（）：类似于 partition()函数,不过是从右边开始.
• splitlines（）：按照行分隔，返回一个包含各行作为元素的列表
• isalpha（）：如果 mystr 所有字符都是字母 则返回 True,否则返回 False
• isdigit（）：如果 mystr 只包含数字则返回 True 否则返回 False.
• isalnum（）：如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
• isspace（）：如果 mystr 中只包含空格，则返回 True，否则返回 False.

列表

比C语言的数组强大的地方在于列表中的元素可以是不同类型的

常用方法：

• append（）：通过append可以向列表添加元素
• extend（）：通过extend可以将另一个集合中的元素逐一添加到列表中
• insert（）：insert(index, object) 在指定位置index前插入元素object
• index（）：index与字符串中的用法相同
• count（）：count与字符串中的用法相同
• pop（）：删除最后一个元素
• remove（）：根据元素的值进行删除
• sort（）：sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
• reverse（）：reverse方法是将list逆置。

列表推导式：

所谓的列表推导式，就是指的轻量级循环创建列表

a = [(x, y, z) for x in range(1, 3) for y in range(3) for z in range(4, 6)]

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

字典

• 字典和列表一样，也能够存储多个数据
• 列表中找某个元素时，是根据下标进行的
• 字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
• 字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
• 用{}包起来

常用方法：

• get（）：除了使用key查找数据，还可以使用get来获取数据
• clear（）：clear清空整个字典
• keys（）：keys返回一个包含字典所有KEY的列表
• values（）：返回一个包含字典所有value的列表
• items（）：返回一个包含所有（键，值）元祖的列表

公用方法

1. 运算符

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	复制	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典

2. python内置函数

Python包含了以下内置函数

序号	方法	描述
1	len(item)	计算容器中元素个数
2	max(item)	返回容器中元素最大值
3	min(item)	返回容器中元素最小值
4	del(item)	删除变量

函数

def 函数名():
    代码

要在函数里使用全局变量那么得使用global

缺省参数：

• 在形参中默认有值的参数，称之为缺省参数
• 注意：带有默认值的参数一定要位于参数列表的最后面

不定长参数：

def functionname([formal_args,] *args, b=22, **kwargs):
   """函数_文档字符串"""
   function_suite
   return [expression]

• 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组

• 而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.

• 如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到 *args的后面， 但如果有**kwargs的话，**kwargs必须是最后的

拆包、交换变量的值

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age


my_high, my_weight, my_age = get_my_info()

• 拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常
• 除了对元组拆包之外，还可以对列表、字典等拆包

引用

• Python中函数参数是值传递
• 所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变
• 可变类型有： 列表、字典、集合
• 不可变类型有： 数字、字符串、元组
• 对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
• 而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量

文件操作

写数据(write)

首先打开文件
然后使用write()可以完成向文件写入数据
最后关闭文件

f = open('test.txt', 'w')
f.write('hello world, i am here!')
f.close()

• 如果文件不存在那么创建，如果存在那么就先清空，然后写入数据

读数据（read）

首先打开文件
然后使用read()可以完成从文件读出数据
最后关闭文件

f = open('test.txt', 'r')
content = f.read(5)  # 最多读取5个数据
print(content)
f.close()  # 关闭文件，这个可以是个好习惯哦

• 如果用open打开文件时，如果使用的"r"，那么可以省略，即只写 open('test.txt')

• read（）：读字节

• readline（）：读一行

• readlines（）：读全部

文件重命名：

os模块中的rename()可以完成对文件的重命名操作

rename(需要修改的文件名, 新的文件名)

os.rename("毕业论文.txt", "毕业论文-最终版.txt")

删除文件：

os模块中的remove()可以完成对文件的删除操作

remove(待删除的文件名)

os.remove("毕业论文.txt")

创建文件夹：

os.mkdir("张三")

获取当前路径：

os.getcwd()

改变默认目录

os.chdir("../")

获取目录列表：

os.listdir("./")

删除文件夹：

os.rmdir("张三")

面向对象

类

class 类名:
    方法列表

• 定义类时有2种形式：新式类和经典类，上面代码中的Hero为新式类，前两行注释部分则为经典类；
• object 是Python 里所有类的最顶级父类；
• 类名 的命名规则按照"大驼峰命名法"；
• info 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量 这个变量指向了实例对象

属性可以在类外面用.属性的方式添加

# 给对象添加属性，以及对应的属性值
taidamier.name = "泰达米尔"  # 姓名
taidamier.hp = 2600  # 生命值
taidamier.atk = 450  # 攻击力
taidamier.armor = 200  # 护甲值

也可以使用构造函数来添加

def __init__(self):
    """ 方法，用来做变量初始化 或 赋值 操作，在类实例化对象的时候，会被自动调用"""
    self.name = "泰达米尔" # 姓名
    self.hp = 2600 # 生命值
    self.atk = 450  # 攻击力
    self.armor = 200  # 护甲值

内部方式使用self来获取属性

def info(self):
    """在类的实例方法中，通过self获取该对象的属性"""
    print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
    print("英雄 %s 的攻击力 :%d" % (self.name, self.atk))
    print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))

构造函数

__init__()方法

"""定义了一个英雄类，可以移动和攻击"""
# Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法，__init__()就是一个魔法方法，通常用来做属性初始化 或 赋值 操作。
# 如果类面没有写__init__方法，Python会自动创建，但是不执行任何操作，
# 如果为了能够在完成自己想要的功能，可以自己定义__init__方法，
# 所以一个类里无论自己是否编写__init__方法 一定有__init__方法。
def __init__(self):
    """ 方法，用来做变量初始化 或 赋值 操作，在类实例化对象的时候，会被自动调用"""
    self.name = "泰达米尔" # 姓名
    self.hp = 2600 # 生命值
    self.atk = 450  # 攻击力
    self.armor = 200  # 护甲值

• __init__()方法，在创建一个对象时默认被调用，不需要手动调用
• __init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。
• 在类内部获取 属性 和 实例方法，通过self获取；
• 在类外部获取 属性 和 实例方法，通过对象名获取。
• 如果一个类有多个对象，每个对象的属性是各自保存的，都有各自独立的地址；
• 但是实例方法是所有对象共享的，只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。

__str__(self)

类似于toString方法

    def __str__(self):
        """
            这个方法是一个魔法方法 (Magic Method) ，用来显示信息
            该方法需要 return 一个数据，并且只有self一个参数，当在类的外部 print(对象) 则打印这个数据
        """
        return "英雄 <%s> 数据： 生命值 %d, 攻击力 %d, 护甲值 %d" % (self.name, self.hp, self.atk, self.armor)

• 在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
• 当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__(self)方法，那么就会打印从在这个方法中 return 的数据
• __str__方法通常返回一个字符串，作为这个对象的描述信息

析构函数

__del__()方法

    # 当对象被删除时，会自动被调用
    def __del__(self):
        print("__del__方法被调用")
        print("%s 被 GM 干掉了..." % self.name)

• 当有变量保存了一个对象的引用时，此对象的引用计数就会加1；
• 当使用del() 删除变量指向的对象时，则会减少对象的引用计数。如果对象的引用计数不为1，那么会让这个对象的引用计数减1，当对象的引用计数为0的时候，则对象才会被真正删除（内存被回收）。

类属性

写在类里面的属性是静态的，写在构造函数里面的是成员变量

class People(object):
    address = '山东'  # 类属性
    def __init__(self):
        self.name = 'xiaowang'  # 实例属性
        self.age = 20  # 实例属性

类方法

是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字，就最好用’cls’了），能够通过实例对象和类对象去访问。

class People(object):
    country = 'china'

    #类方法，用classmethod来进行修饰
    @classmethod
    def get_country(cls):
        return cls.country

当方法中 需要使用类对象 (如访问私有类属性等)时，定义类方法
类方法一般和类属性配合使用

静态方法

需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数，可以通过对象和类来访问。

class People(object):
    country = 'china'

    @staticmethod
    #静态方法
    def get_country():
        return People.country

当方法中 既不需要使用实例对象(如实例对象，实例属性)，也不需要使用类对象 (如类属性、类方法、创建实例等)时，定义静态方法取消不需要的参数传递，有利于 减少不必要的内存占用和性能消耗

封装

封装的意义：

1. 将属性和方法放到一起做为一个整体，然后通过实例化对象来处理；
2. 隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了；
3. 对类的属性和方法增加 访问权限控制。

私有权限：在属性名和方法名 前面 加上两个下划线 __

1. 类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问；
2. 类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问；
3. 私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。

修改私有属性的值

Getter

Setter

总结

• Python中没有像C++中 public 和 private 这些关键字来区别公有属性和私有属性。
• Python是以属性命名方式来区分，如果在属性和方法名前面加了2个下划线’__'，则表明该属性和方法是私有权限，否则为公有权限。

继承

# 父类
class A(object):
    def __init__(self):
        self.num = 10

    def print_num(self):
        print(self.num + 10)
# 子类
class B(A):
    pass

• 子类在继承的时候，在定义类时，小括号()中为父类的名字

• 父类的属性、方法，会被继承给子类

• 多继承可以继承多个父类，也继承了所有父类的属性和方法

• 注意：如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）

• 多个父类中，不重名的属性和方法，不会有任何影响。

重写

如果子类和父类的方法名和属性名相同，则默认使用子类的

调用父类属性方法

调用父类方法格式：父类类名.父类方法(self)

无论何时何地，self都表示是子类的对象。在调用父类方法时，通过传递self参数，来控制方法和属性的访问修改。

也可以使用super()方法

# super()的简化版，只支持新式类
super().__init__()  # 执行父类的 __init__方法
super().make_cake()  # 执行父类的 实例方法
self.make_cake()  # 执行本类的实例方法

子类继承了多个父类，如果父类类名修改了，那么子类也要涉及多次修改。而且需要重复写多次调用，显得代码臃肿。

使用super() 可以逐一调用所有的父类方法，并且只执行一次。调用顺序遵循 mro 类属性的顺序。

注意：如果继承了多个父类，且父类都有同名方法，则默认只执行第一个父类的(同名方法只执行一次，目前super()不支持执行多个父类的同名方法)

super() 在Python2.3之后才有的机制，用于通常单继承的多层继承。

多态

和C++、Java一样，特殊的一种继承

异常

跟C++、Java一样

捕获异常

try-except-else-finally

try:
    print('-----test--1---')
    f = open('123.txt', 'r')  # 如果123.txt文件不存在，那么会产生 IOError 异常
    print('-----test--2---')
    try:
        print(num)  # 如果num变量没有定义，那么会产生 NameError 异常
    except (IOError, NameError):
        # 如果想通过一次except捕获到多个异常可以用一个元组的方式
        print("捕获异常")
    else:
        print('没有出现到异常，真高兴')
    finally:
        f.close()
        print('关闭文件')
except NameError as result:  # 捕获所有异常并存储异常的详细信息
    print("没有这个文件")

模块

在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包类似

• 在Python中用关键字import来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。

• 可以根据__name__变量的结果能够判断出，是直接执行的python脚本还是被引入执行的，从而能够有选择性的执行测试代码

if __name__ == 'main':
	# 测试代码

• 如果一个文件中有__all__变量，那么也就意味着这个变量中的元素，会被from xxx import *时导入,没有在这个变量中的不会被导入

• 包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为__init__.py 文件，那么这个文件夹就称之为包

• 有效避免模块名称冲突问题，让应用组织结构更加清晰