python 基础

局部与全局

声明全局变量 global

数据存储

列表

变量 = [数据1,数据2]
变量[索引]

基本：

排序：

添加数据：

删除：

del 关键字本质上是用来将变量送内存上删除

range(start, stop[, step])函数

参数说明：

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

元组

• 与列表类似，但元素无法修改
• 元组表示多个元素组成的序列

变量 = (数据1,数据2,···)
变量.[索引]

注意:定义一个元组时需要带个括号：a = (1,)

转换命令：
字符串也是可以直接转换的

函数的返回

如果由多个数据的返回值，return 使用元组返回（小括号可以省略）,接收使用与返回相等的变量接收

交换两个变量:

a,b = (b,a)     # 小括号可以去掉
# 等价于
# c = a
# a = b
# b = c

字典

键 key 是索引，只能由字符串,数字,元组构成
值 value 是数据,可以取任何类型

变量 = {key1:value,key2:value2,···}
变量.[key2]

基本操作：

字符串

变量 = "数据"
变量[索引]

基本：

判断：

查找与替换：

注意：replace方法执行后会返回一个新字符串，不会修改原内容

文本对齐：

去除空白字符：

拆分与连接：

# 合并示例：
print(' and '.join(['Mary','John','Amy']))  # ---> Mary and John and Amy
print(' 你和{}和{}'.format('我','他'))       # ---> 你和我和他

字符串格式化

切片

使用索引值来分割，适用于字符串、列表、元组
格式：字符串[开始索引:结束索引[:步长]]

公共方法

cmp python3中已经取消

运算符：

注意：in 对字典操作时，判断字典的key

函数

省略参数：

如果想为参数指定默认值，可以在接收时建立，示例：

def info(name, gender=True)：
    ···

info("xiaoming")

多个参数

• 参数名前面添加一个*可接收元组
• 参数名前面添加两个*可接收字典
• 再给多个参数命名时，习惯使用：
  • *args---存放元组
  • **kwargs---存放字典

示例：

def demo(name, *args, **kwargs):
    ···
    
# 1存放在name中，2，3存放在元组中，后面两个name与age存放在字典中
demo(1,2,3,name='fasfd',age=11)

拆包

调用多值参数时使用变量，可以使用拆包

def demo(*args, **kwargs):
    ···

gl_nums = (2,34)
gl_dict = {"name":"xiaoming","age"=18}
demo(*gl_nums,**gl_dict)

从函数中返回函数

其实并不需要在一个函数里去执行另一个函数，我们也可以将其作为输出返回出来：

def hi(name="yasoob"):
    def greet():
        return "now you are in the greet() function"
 
    def welcome():
        return "now you are in the welcome() function"
 
    if name == "yasoob":
        return greet
    else:
        return welcome
a = hi()    # 执行hi()  如果换成hi()()便会执行hi()中的greet()函数
print(a)
#outputs: <function greet at 0x7f2143c01500>
#上面清晰地展示了`a`现在指向到hi()函数中的greet()函数
#现在试试这个
print(a())
#outputs: now you are in the greet() function

当把一对小括号放在后面，这个函数就会执行；然而如果你不放括号在它后面，那它可以被到处传递，并且可以赋值给别的变量而不去执行它。 你明白了吗？让我再稍微多解释点细节。

当我们写下 a = hi()，hi() 会被执行，而由于 name 参数默认是 yasoob，所以函数 greet 被返回了。如果我们把语句改为 a = hi(name = "ali")，那么 welcome 函数将被返回。我们还可以打印出 hi()()，这会输出 now you are in the greet() function。

将函数作为参数传给另一个函数

def hi():
    return "hi yasoob!"
def doSomethingBeforeHi(func):
    print("I am doing some boring work before executing hi()")
    print(func())
doSomethingBeforeHi(hi)
#outputs:I am doing some boring work before executing hi()
#        hi yasoob!

修饰器

修饰器具体使用

面向对象

类名.属性 --> 类属性

推荐使用上述方法来访问对象的属性，不推荐使用 对象.类属性

class tool(object):
    count = 0
    def __init__(self,name) :
        self.name = name
        tool.count += 1
        
tool1 = tool("123")
tool2 = tool("3222")
print(tool.count)   ## 返回 2

类名.方法 --> 类方法（cls）
类名() --> init定义实例属性
对象名.方法名() --> 实例方法(self)

类方法

格式：

@classmethod
def 类方法名(cls)
    pass

注意：类方法需要传入cls参数

可以通过 cls 访问类的属性、类的其他方法

静态方法

格式：

@staticmethod
def 静态方法名()
    pass

通过 类名.静态方法 调用，无需创建对象

实例方法、类方法、静态方法对比

有以下类定义三个方法：

class MyClass(object):
    # 实例方法
    def instance_method(self):
        print('instance method called', self)
    
    # 类方法
    @classmethod
    def class_method(cls):
        print('class method called', cls)
    
    # 静态方法
    @staticmethod
    def static_method():
        print('static method called')

my_class = MyClass()        # 实例化
my_class.instance_method()  # 实例方法
my_class.class_method()     # 类方法
my_class.static_method()    # 静态方法

1. 当实例化时，my_class指向实例化对象：

2. 当调用实例方法(instance method)时，self参数指向的是刚刚实例化出的my_class实例对象:

3. 当调用类方法(class method)时，cls参数指向的是一开始定义的MyClass类对象（注意不是实例对象）：

4. 当调用静态方法(static method)时：

通过类对象调用静态方法时，这里的结果与通过实例对象调用是完全一样的。通过实例对象调用静态方法时，实例对象也会被忽略，而是通过其类对象进行调用，这一点与类方法的调用是一样的。

注意：不管self参数，还是cls参数，都是一种约定俗成的用法，其实是可以使用其他的参数名代替。但是不建议使用其他参数名，毕竟代码不是只是写给自己看的。

魔法方法

使用 dir(对象) 方法可以查询对象包含的方法和属性。

__new__ 方法

• __new__ 是一个由 object 基类提供的 内置静态方法 作用：
  • 使用 类名() 创建对象时，python解释器 首先 调用 __new__ 方法为对象分配空间。
  • 返回 对象的引用
  • python获得引用后，将引用 第一参数 传给 __init__ 方法

    player = MusicPlayer()
      .            .
     /|\          /|\                   ___________________
      |            |                    |   MusicPlayer   |
________________   |                    |   __new__(cls)  |
|  __new__     |   |                    |   __init__(self)|
|1. 为对象分配空|______________          ___________________
|2. 返回对象引用|  __init__   |
---------------|1.对象初始化  |
               |2.定义实例属性|
                --------------

对 __new__ 方法的重写 需要 return super().__new__(cls)
否则，python得不到分配的 引用对象 ，就不会调用对象的初始化方法

__new__ 是一个 静态方法 在调用时 主动传递 cls参数

class MusicPlayer(object):
    instance = None     # 记录对象引用
    def __new__(cls,*args,**kwargs):
        # 判断是否为空
        if cls.instance is None:
            # 调用父类方法
            cls.instance = super().__new__(cls)
        return cls.intance

只执行一次初始化动作

• 每使用 类名() 创建对象时，都会自动调用两个动作。
• 前一个对 __new__ 方法改造后，每次都会传递到 第一次创建对象的引用
• 初始化方法还会被再次调用

方法：

···
class MusicPlayer(object):
    init_flag = False       # 标记是否 执行初始化动作
    ···
    def __init__(self):
        if MusicPlayer.init_flag:
            print("初始化")
            MusicPlayer.init_flag = True
    ···

身份运算符

x is y 类似与id(x)==id(y),身份标识符用于比较两个对象内存地址是否一致

继承

Class 类名(父类名):
    super.方法名()  # 重写方法

在 python3.x ，不指定父类，会默认使用object
在 python2.x ，不指定父类，便没有

异常

捕获异常格式：

try:
    尝试执行的代码
except  错误类型1:
    出现错误的处理
except 错误类型2:
    针对错误类型2，对应的处理
except Exception as result:
    # 捕获未知错误
    print("未知的错误%s" % result)
else:
    没有异常才会执行的代码
finally:
    无论是否有异常都会执行的代码

主动抛出异常

python 提供一个 Exception 异常类，使用 raise 关键字抛出异常
实例：

def input_Passsword():
    pund = input("请输入密码")
    if len(pund) >= 8:
        return pund
    print("异常")
    ex = Exception("密码长度不够")
    raise ex

try:
    print(input_Passsword())
except Exception as result:
    print(result)

模块的使用

模块的导入

格式：
import 模块名 as 模块别名导入模块 或者
from 模块名 import 工具名 as 别名从模块导入某个工具

如果两个模块存在 同名函数 ，那么 后导入的函数 会 覆盖前导入的函数

from 模块名 import * 导入模块中的全部工具

模块的搜索顺序

导入模块时：

• 搜索 当前目录 指定模块名文件 如果有便直接导入
• 如果没有，在搜索 系统目录

__file__ 查看 模块的完整路径

开发原则

• 一个 独立的 python 文件 就是一个模块
• 在导入文件时，文件中 所有没有任何缩进的代码都会被执行

__name__ 属性

• __name__ 是python内置属性，记录着字符串
• 如果 是被其他文件导入 ，__name__ 就是 模块名
• 如果 是当前执行程序， __name__ 是 __main__

包

• 包是一个 包含多个模块 的 特殊目录
• 目录下有一个 特殊文件 __init__.py
• 包名 命名方式 与变量名一致
• 使用 import 包名 一次性导入所有 模块

__init__.py

要在外界使用 包 中的模块，需要在 __init__.py 中指定 对外界提供的模块列表

# __init__.py
from . import 模块1
from . import 模块2

文件操作

open 函数第一个参数是要打开文件名（文件区分大小写）

• 如果存在，返回文件对象
• 如果不存在，抛出异常

read 方法一次 读入 并 返回 文件的所有内容

close 方法关闭文件

• 如果忘记关闭，会 造成系统资源消耗

file = open("README")
text = file.read()
print(text)
file.close()

文件指针

• 文件指针 标记 从哪个位置开始读取数据
• 第一次打开文件，通常文件指针指向文件开始的位置
• 当执行 read 方法后，文件指针会移动到 末尾

文件打开方式

open 函数默认打开为只读文件

语法：
f = open("文件名", "访问方式:)

注意：频繁移动指针，会影响读写效率，

按行读取文件

• read 方法默认把 所有文件一次性读取到内存
  • 如果文件太大，对内存占用非常严重
• readline 方法可以一次读取一行内容
  • 方法执行后，会把 文件指针 移动到下一行再次读取

示例：

file = open("README")
while True:
    text = file.readline()
    if not text:
        break
    print(text)
file.close()

复制文件示例

file_read = open("···")
file_write = open("···")
while True:
    text = file_read.readline()
    if not text:
        break
    file_write.write(text)
file_read.close()
file_write.close()

eval 函数

eval 函数,将 字符串 当成 有效的表达式 来求值并返回 计算结果

示例：

eval("1+1") # 2
typeleval("[1,2,3]")    # list
typeleval("{'name':'123','age':'23'}")  # dict

经典案例：

input_str = input("请输入一个算式")
print(eval(input_str))

注意不要滥用eval()

eval()由安全隐患（与PHP类似，防止命令注入攻击）
示例：

# 在上面的计算器中执行：
__import__('os').system('ls')   # 这样会使用当前用户执行当前终端的代码

本栏目推荐文章
• Python学习笔记
• python字典的使用
• python字符串方法
• python列表和元组使用介绍
• python | 小游戏 开局托儿所 自动化脚本 pyautogui
• 【Shell基础】Bash基础与Linux三剑客
• python中的Map和Filter
• python-爬元气桌面壁纸
• python中的*args**和**kwargs
• Python教程(23)——Python类中常用的特殊成员

基础 python基础python unittest基础python 语法 基础python 基础python 100 对象 基础python 模块 基础python 函数 基础python 对象 基础 笔记python 基础知识 基础 知识python 基础python set