正好最近在学python，感觉有语言基础的话更多在乎一些语法糖，毕竟其他东西在之前应该接触过了。
笔者C++是起始语言，也接触过java、js，介绍一点python的特点吧。帮助自己巩固所学，也希望能帮助别人快速上手。

一.语言本身特点

python是一门解释型语言。 解释型语言与编译型语言： 解释型语言：先翻译成中间代码，再由解释器对中间代码进行解释运行。程序不需要编译，在运行时才翻译成机器语言，每执行一次都要翻译一次。效率比较低。典型如js，相当于吃火锅，想吃啥煮啥 编译型语言：将所有源代码一次性转换成二进制指令，即生成一个可执行文件。典型如C/C++，相当于炒菜，从原材料到菜有编译过程 半解释半编译：典型如java，相当于干锅，加热到一半（半熟）然后放桌上继续加热 ![]()

Python中，万物皆对象
可变对象mutable：列表/集合/字典，自定义对象等:可以在原来地址空间进行修改
不可变对象immutable：字符串，数字int，元组等:不可以在原地址修改，而是要另辟内存空间

二.语法基础

1.标识符

区分大小写

可以用下划线、字母、数字、中文、日文……

不能用关键字

不能使用python自带函数

def func1():
    Myname=2
    myname=3
    print(myname)
    print(Myname)
    # false=True   not recommended but true
    # print(false)
    派松=4
    print(派松)
    ゆめ=7
    夢=8
    ソフトウェア=9

2.数据类型

整数可以很大，不是int的范围。 没有long和int 复数类型：用a+bj形式表示（a,b∈R） 布尔类型：是整数类型子类。返回值为False的类型：None，False，0, 0.0, 0j, ‘’,””,[],(),{}

字符串类型：
普通字符串：可以用单引号也可以用双引号包裹的字符串
原始字符串：在普通字符串前加r，转义字符无效。
长字符串：用三重单引号或三重双引号包裹的字符串，可以显示换行缩进等字符。

def func3():
    print('abc') #abc
    print("def") #def
    print('''xxx''') #xxx
    s="""a
    bc
    def
        ghi
    """
    print(s)
    #a
    #bc
    #def
    #    ghi
    
    a=r'\u0048'
    b='\u0048'
    c="yyy\\yyy"
    print(a) #\u0048
    print(b) #H
    print(c) #yyy\yyy

.format用法

def func4():
    name="tom"
    age=30
    print(name+' is '+str(age)) #tom is 30
    s1='age is {0}'.format(age) 
    print(s1)  #age is 30
    s2='{0}\'s age is {1}'.format(name,age)
    print(s2) #tom's age is 30
    s3='{n}\'s age is {a}'.format(n=name,a=age)
    print(s3) #tom's age is 30

    money=1234.554
    print('{0}今天收入是{1:f}元。'.format(name, money)) #tom今天收入是1234.554000元。
    print('{0}今天收入是{1:.2f}元。'.format(name, money))  #tom今天收入是1234.55元。
    print('{0}今天收入是{1:g}元。'.format(name, money)) #tom今天收入是1234.55元。
    print('{0}今天收入是{1:e}元。'.format(name, money)) #tom今天收入是1.234554e+03元。

可通过int(),str(),bool()完成相互转换

3.运算符

特殊的：

/ 正常除法

** 幂

// 整数除法
逻辑运算（虽然C++后来标准也支持这些英文单词）

  • not 非
  • and 与
  • or 或

没有三元运算符?:
采用 expression if judgement else expression2 来替代

x=5
print("great" if x>3 else "bad") #great
x=2
print("great" if x>3 else "bad") #bad

同一性测试运算符：判断两个对象是否是一个对象，即判断id

def func4():
    a=257
    b=257
    print(id(a))
    print(id(b))
    print(a is b)
    c=1234567812345678
    d=1234567812345678
    print(c is d)

4.控制语句

不习惯的地方：

  1. 判断语句不用括号
  2. 判断语句结束加:
  3. 不用大括号而用缩进表示代码块
  • 分支语句
if judgement1:
  expression1
  if judgement4:
    expression4
    experssion5
elif judgement2:
  expression2
else :
  expression3

没有switch！

  • 循环语句
    python没有do while
    python在循环后新增了else，当循环正常退出时将进入else（如果遇到break,return,异常时将不进入else）
  1. while
while judgement :
  expression1
  expression2
while judgement :
  expression1
  expression2
else :
  expression3
  1. for
for .. in .. :
  expression1
  expression2
for .. in .. :
  expression1
  expression2
else:
  expresssion3

range()

  • range(x)表示[0,x-1)
  • range(start,stop)表示[start,stop)，以步长为1进行遍历
  • range(start,stop,step)表示[start,stop)并以step步长遍历
def func17():
    for x in range(6):
        print('{0} '.format(x),end="")  #0 1 2 3 4 5
    print()
    for x in range(0,6):
        print('{0} '.format(x),end="")  #0 1 2 3 4 5
    print()
    for x in range(0,6,2):
        print('{0} '.format(x),end="")  #0 2 4

5.函数

通过def关键字来定义函数

def function_name(params):
  expression1
  expression2
  return ret #can be omitted

关键字参数：使用形式参数的名字来确定输入的参数值。
可以采用关键字参数调用函数，但使用关键字参数后，之后的参数也必须使用关键字参数
函数参数可以有默认值，但有默认值的参数必须放在最后

不定长参数
*可变参数：被组装成元组 不是最后一个参数时，后面的参数需要用关键字参数形式传递
**可变参数：被组装成字典 必须放在所有参数最后

但可变参数/**可变参数不能由已有变量传递，需要通过/**进行拆包才能进行传递。

def func12(*sum,multiple=1.0):
    total=0.0
    for num in sum:
        total+=num
    print(total*multiple) 
func12(2,3,4)
tp=(3,4,5) #12
#func12(tp) #wrong
func12(*tp)
func12(1,2,*tp) #15

变量作用域
函数内创建，即为函数的局部变量，优先级更高
使用global关键字可修改全局变量

函数嵌套
函数可以嵌套
内部函数可以访问外部函数变量
外部函数不能访问内部函数变量
内部函数不能被外部函数以外的地方访问

x = 20
def print_val():
    x=15
    print("函数中x = {0}".format(x))

def print_value():
    global x
    print("函数中x = {0}".format(x))
    x = 10
    print("函数中x = {0}".format(x))

print_val() #15
print_value() #20 10 
print("全局变量x = {0}".format(x)) #10

6.类

class关键字

class ClassName:
class ClassName:
  def __init__(self,param1,param2):
    self.attribute1=param1
    self.attribute2=param2

对象实例变量
存储描述对象的状态特征的值
在内部通过self.变量名访问
在外部通过对象名.变量名访问
对象构造完后，还可以为对象增添属性

类变量
所有实例都共有的变量
在内部通过self.变量名方法
在外部通过对象名.变量名访问
类变量一直存储在内存中。
用对象名.变量名修改类变量时会增加一个同名的实例变量。
__dict__查看所有实例变量

对象构造完后，可以为对象增加实例变量
修改对象的类变量不会修改类的类变量值，只会修改该对象的类变量值
一个类只能有一个构造函数
用对象名.变量名修改类变量时会增加一个同名的实例变量。

实例方法
普通方法，属于对象所有的
第一个参数必须是self

类方法
特殊方法，属于类所有的
第一个参数必须是cls
只能访问类变量和其他类方法
使用@classmethod装饰
类似于java的static方法

静态方法
不属于类/对象
只是需要一个类作为依托
采用@staticmethod装饰
C++/JAVA的静态方法指之前的类方法
python的静态方法不能访问类里的内容，只是挂号方法

class Account:
    rate=0.06
    def __init__(self,owner,amount):
        self.owner=owner
        self.amount=amount
    
    @classmethod
    def calc(cls,amt):
        return cls.rate*amt
    
    @staticmethod
    def interest(amt):
        return Account.calc(amt)

acc=Account("tom",10000)
# print(acc.calc(10000)) #wrong
print(Account.calc(10000)) #600.0
print(acc.interest(11000)) #660.0
print(Account.interest(12000)) #720.0

什么都不做的类，pass
name 获取类的名称
module 获取类的模块
bases 获取类的所有父类
dict 获取类的所有属性和方法

信息隐藏
私有类变量： 在变量名字前面增加__
私有实例变量：在变量名字前面增加__
私有实例方法：在方法前面增加__
在类内部访问该私有成员时也需要加上__，即self.__
外界无法直接访问私有成员
但是可以通过_类名__变量名访问私有变量
但是可以通过_类名__方法名访问私有方法
Python封装性主要靠程序员自觉（python的私有成员还真是公开啊~）

class Circle():
    def __init__(self,r):
        self.__radius =r
    def getArea(self):
        return math.pi*self.__radius*self.__radius
    
    def test1(self):
        # self.hidden() #wrong
        self.__hidden()
        print("this is a test")

    def __hidden(self):
        print("hidden")

    @classmethod
    def expand(cls,times):
        print("cls")
        # return getArea()*times #wrong:cannot get getArea
        return times

def func2():
    circle=Circle(3)
    # print(circle.radius) #wrong
    # print(circle.__radius) #wrong
    circle._Circle__hidden() #hidden
    print(circle._Circle__radius) #3
    circle.test1() #hidden this is a test
    print(circle.expand(3)) #cls 3

可以像java一样使用get和set方法来访问变量达到封装效果。

@property
def variable_name(self):
    return self.__variable_name

@variable_name.setter
def variable_name(self,variable_name):
    self.__variable_name=variable_name

有了上述定义后，可以使用obj.variable_name访问属性，用obj.variable_name=value修改属性值

类继承
子类继承父类所有成员变量和方法，除了私有部分
如果子类有构造函数，则默认不自动调用父类构造函数
如果子类没有构造函数，在创建子类对象时会自动调用第一个父类的构造函数(相同参数列表)
如果有多继承，采用MRO算法，从父类开始，深度优先，从左到右，除了pass以外，碰到的第一个父类构造函数，参数列表吻合，就创建。如果不吻合，就报错。
使用super()可以调用父类所有的东西

多态
允许重写方法。需要子类方法名和父类的方法名相同，参数列表相同
子类对象转型为父类，但实际上执行是自身的方法
isinstance(obj_name,class_name)方法可以判断对象是否属于某个该类
issubclass(class1,class2)方法可以判断class1是否是class2的子类

object类是所有类祖宗
__str()__方法：输出描述信息
__eq()__方法：对象比较方法
内存地址相同则相同，不一样再比较eq方法

枚举类
管理一组有限个常量的集合，需要import enum
@enum.unique 装饰器，保证成员取值不同

7.数据结构

  • 序列：可迭代，元素有序，可以重复出现
  • 集合：可迭代，元素无序，不能重复出现
  • 字典：可变可迭代的K-V对
  1. 序列：可迭代、有序、可重复

列表 list 列表：可变的序列，使用[]创建，逗号分隔

  • 追加元素 list.append(element)
  • 追加列表 list.extend(list2)
  • 插入元素 list.insert(element)
  • 替换元素 list[i]=element
  • 删除元素 list.remove(x) 从左到右，只删除第一个
list.pop(i)    删除第i个，并返回
del list[i]    删除第i个
  • reverse：将列表反转
  • copy：拷贝
  • clear：清空
  • index：返回x元素所在的位置
  • count：返回x出现的次数

字符串 str
元组 tuple 元组：不可变的序列，使用()创建，逗号分隔。不存在单元元组，当元组只有一个元素时会被认为是该元素的类型。
范围 range
字节序列 bytes
序列可以进行的操作：索引、分片、加和乘

  1. 集合：无序，不能重复，逗号隔开，用{}包围
    创建空集合，用set()
    add(elem) 增加一个元素
    remove(elem) 删除元素，如果不存在，则报错
    discard(elem) 删除元素，如果不存在，不报错
    pop() 删除返回任一元素
    clear() 清除集合
    不可变集合：frozenset
  2. 字典：可变可迭代的数据结构，K-V对
    {key1:val1, key2:val2, key3:val3}
    采用dict()创建
    get(key) 返回这个key对应的value
    items() 返回字典的所有键值对
    keys() 返回所有keys
    values() 返回所有的values
    采用for循环进行遍历
    s={}创造的是空字典而非空集合

8.模块

导入方式

import module_name
import module_name as new_name
import module_name1, module_name2
from module_name import function_name,variable,class_name

import module_name 会导入模块所有代码元素，访问时需要加module_name.
from module_name import function_name,variable,class_name 导入模块特定元素，访问时不需要加module_name

导入模块的搜索顺序，是按照sys.path变量值搜索路径：
当前目录\(\rightarrow\)Python安装目录\(\rightarrow\)PYTHONPATH环境变量
添加路径方式：
①临时添加：使用sys.path.append(“xxx”)临时添加路径
Python解释器重启后无效
②永久添加：在Python安装目录或者Lib\site-packages目录新建xx.pth
在xx.pth中，每行一个路径
③使用PYTHONPATH环境变量添加，多个路径用分号隔开

9.包

把功能相近的模块文件放在同一个目录下，就是包Package

  • 这个目录必须有一个__init__.py文件
  • init文件内容可以为空，也可以设置__all__的值用于限定导入范围
  • 包可以包含子包，没有层级限制
  • 每个子包都必须包含一个__init__.py文件
  • 包可以有效避免模块命名冲突

包的导入和调用

import package1.sub_package1.module1_1
from package1.sub_package1 import module1_1
from package1.sub_package1.mudule1 import func1
from 包名 import *
#可以使用相对路径
from . import module1_2
from .. import sub_package2
from .. sub_package2 import module2_1

库
库：library，具有相同功能模块的集合，本质上还是包和模块，方便他人引用

异常
BaseException: Python异常总祖宗
Exception
ArithmeticError
StopIteration
Warning
RuntimeWarning
…
…
SystemExit
……

捕获异常

try:
    expression1
    expression2
except error_type1:
    expression3
except error_type2:
    expression4
else:
    expression5
finally :
    expression6

大异常写下面，小异常写上面
可以使用使用traceback.print_exc查看错误堆栈信息
else 提供了更细粒度控制，也可以没有
finally可以没有，但不管try，except结果如何，必须执行finally

with open(filename) as file:
    expression1
    expression2

with…as语句 可以自动释放资源，推荐使用

自定义异常
继承Exception类或者子类
提供一个字符串参数的构造函数

class MyException(Exception):
    def __init__(self,message):
        super().__init__(message)

显式抛出异常：可以使用raise语句主动抛出异常
raise MyException('...')

常用的模块和库

Python提供math模块进行基础数学运算
math.ceil(x): 返回大于等于x的最小整数
math.floor(x): 返回小于等于x的最大整数
math.round(x): 对x进行四舍五入
math.log(a, base): 返回以base为底，a的对数
math.sqrt(a): 返回a的平方根
math.pow(a,b): 返回a的b次方

随机数模块提供一些随机数函数
random.random()：返回[0,1)之间的小数
random.randrange(stop)：返回[0,stop)步长为1的随机整数
random.randrange(start.stop[,step])：返回[start,stop)之间步长为step的随机整数
random.randint(a,b)：返回[a,b]之间的随机整数

datetime模块
datetime类：datetime类需要用datetime.datetime.function_name()来调用
datetime(year, month, day, hour=0,minute=0,second=0, microsecond=0, tzinfo=None), microscond微秒
datetime.today(): 返回此刻日期和时间
datetime.now(tzinfo): 返回指定时区的此刻时间和日期，如tz未指定，等同于today()
datetime.utcnow(): 返回当前utc日期和时间
datetime.fromtimestamp(timestamp, tz=None)：返回与UNIX时间戳对应的本地日期和时间, 1970-01-01 00:00:00开始
datetime.utcfromtimestamp(timestamp)：返回与UNIX时间戳对应的UTC日期和时间
datetime.timedelta(days, seconds, microseconds, milliseconds, minutes, hours, weeks) 所有参数都是可选的，可以是正数负数
datetime.strftime(format)（比如'%y-%m-%d'）

字符串其他功能
下标和切片：a[2], a[-1], a[:5], a[2:5]
包含：in 和 not in
大小写：upper(), lower(), isupper(), islower()
isalpha(): True, 如果字符串只包含字母，并且非空
isalnum(): True,如果字符串只包含数字字母，并且非空
isdecimal(): True,如果字符串只包含数字，并且非空
startswith(a) 和 endsWith(a)：以某某开头，或者某某结尾

字符串其他功能
字符列表拼接：join, 将列表中多个字符串连起来
字符串分裂：split, 将一个大字符串分裂为多个字符串
文本居中: center()
对齐文本: ljust(), rjust
去除字符串两头的空格：strip(), lstrip(), rstrip()
查找字符串，并返回位置索引，如果找不到，返回-1
index(), 找不到报异常
find()，找不到不报异常
替换字符串：replace(str1, str2)

Python提供copy模块，可生成新的拷贝
copy.copy()浅复制 会跟着原对象变
copy.deepcopy()深复制，包括深层次的嵌套 不会跟着原对象变
is 比较两个对象内存地址是否相等
==比较内容是否相等，调用__eq__（）方法

文件读写

文件系统是由OS管理的
文件系统和Python程序/进程是平行的
文件系统是由文件夹和文件递归组合而成
文件目录分隔符
Linux/Unix 用/隔开
Windows用\隔开。在程序中可以用/或\代替
文件包括文件里面的内容和文件属性
文件属性：名称、大小、扩展名等

Python使用os模块进行文件系统管理
os.rename(src, dst): 将src文件名字修改为dst
os.remove(path): 删除文件，如果删除目录，引发异常
os.mkdir(path): 创建新目录，如果存在，引发异常
os.rmdir(path): 删除目录，如果目录非空，引发异常
os.walk(top): 遍历top所有子目录，自顶向下，返回一个三元组
os.listdir(dir): 列出指定目录下的所有文件和子目录
os.curdir: 当前目录
os.pardir: 上一级目录

Python提供了os.path模块对文件路径进行管理
os.path.abspath(path): 返回path绝对路径
os.path.basename(path): 返回path的基础部分
os.path.dirname(path): 返回path中的目录部分
os.path.exists(path)：判断path是否存在
os.path.isfile(path): 判断path是否是文件
os.path.isdir(path): 判断path是否是目录
os.path.getatime(path): 返回文件最后访问时间戳
os.path.getmtime(path): 返回文件最后修改时间戳
os.path.getctime(path): 返回文件创建时间戳
os.path.getsize(path): 返回文件大小，以字节为单位

文本文件读写
read(size=-1)：读取size个字符，-1表示不限，下同
readline(size=-1)：读取单行字符
readlines(hint=-1)：读取每一行到一个列表中，hint表示行数
write(s)：将s写入到文件中
writelines(lines)：向文件写入一个列表，不添加分隔符
flush()：刷新缓存区，写入到文件中

| |文件读写 |读 |写
| ---- | ---- | ---- |
| | | |