python语言基础

python语言基础 一

1.1 python程序的构成

python程序可以分解为模块、语句、表达式和对象。从概念上理解，其对应关系如下。

(1)python程序是由模块组成，模块对应的扩展名是.py的源文件。一个python程序由一个或者多个模块组成的。

(2) 模块由语句组成。模块即python源文件。在执行python程序时按照依次执行模块中的语句

(3)语句是python程序的过程构造块，在创建对象、构造函数、变量赋值、调用函数、控制分支、创建循环、增加注解等。

(4)表达式用于创建和处理对象。

# 假设已知三角形三条边a,b,c，求三角形的面积（s.py)。三角形的面积公式：s=sqrt(h*(h-a)*(h-b)*(h-c)),其中h表示三角形的周长
import math         # 导入内置模块math和定义的源文件s.py
a=3.0               # 变量赋值语句
b=4.0
c=5.0
h=(a+b+c)/2
s=math.sqrt(h*(h-a)*(h-b)*(h-c))
# 表达式语句，将表达式右边的运算结果为一个新的float类对象，math.sqrt调用math模块中的sqrt()函数，计算参数对象的平方根
print(s)        # 调用函数表达式的语句

1.2 python对象和引用

1.2.1 python对象概述

计算机程序通常用于处理各种类型的数据（即对象），高级语言（java、python、JavaScript、go、c++)都是面向对象的语言，不同的数据属于不同的数据类型，支持不同类型的运算操作。在python语言中，数据表示对象。对象的本质上是一个内存块，拥有特定的值，支持特定类型的运算操作。

在python3中，一切皆对象。python语言中的每个对象由标识（identity）、类型（type）和值（value）标识。

（1)标识用于唯一地标识一个对象，通常对应对象在计算机内存中的位置。使用内置函数id(value)可以返回对象object的标识

（2）类型用于标识所属的数据类型，数据类型用于限定对象的取值范围以及允许执行的处理操作。使用内置函数type（object）可以返回对象object所属的数据类型

（3）值用于表示对象的数据类型的值。使用内置函数print(object)可以返回对象object的值

通过内置的type()函数可以判断一个对象的类型。通过内置的id()函数可以获取一个对象唯一的id表示。也就是说对象三要素：要有内置的type()函数、内置的id()函数、打印它的值

# 用IDLE打开执行
123             # 输出：123
id(123)         # 输出：2444759357616 是指这个数的id地址，该数据存储在每个电脑的id是不一样的
type(123)       # 输出：<class'int'>
print(123)      # 输出：123
​
# 函数和类也是对象，所以也有相应的类型和id
type(abs)       # 输出：<class 'builtin_function_or_method'>
id(abs)         # 输出：1708666055712

1.2.2 创建实例对象

python的数据类型定义了一个值的集合，在python代码中使用字面量表示某个数据类型的值。

# 用字面量创建实例对象
12、101      # 表示int数据类型的值
0.17、3.14   # 表示float数据类型的值
True         # 表示bool数据类型的值（False、True)
'hello'      # 表示str数据类型的值
​
# 类对象创建实例对象
int(12)         # 输出：12
complex(1,2)    # 输出：1+2*j

1.2.3 数据类型

python的数据类型有整数数据类型（int）、浮点数据类型（float）、布尔数据类型（bool）、字符串数据类型（str)、列表（list)、元组（tuple)、字典（dictionary)、集合（set)。

1.2.4 变量和引用

python对象是位于计算机内存的一个内存中的一个内存数据块。为了引用对象，用户必须通过赋值语句把对象赋值给对。指向对象的引用即变量。

a=1     # 字面量表达式创建值为1的int类型实例对象，并绑定到变量a
b=2     # 字面量表达式创建值为2的int类型实例对象，并绑定到变量b
c-a+b   # 表达式a+b创建值为3的int类型实例对象，并绑定到变量c

字面量用于创建之为字面量的对象，即某个数据类型的实例对象；表达式使用运算符实例实现多个操作数（对象）的运算操作，并返回结果对象。用户可以把对象通过赋值语句赋值给一个变量，即把对象绑定到一个变量。

值得一说的是python是动态类型语言，也就是变量不需要声明数据类型，只需要根据变量的赋值，python会自动的确定其数据类型（JavaScript也是如此）。同时，python是一门强类型的语言，每个变量指向的对象均属于某个数据类型，即只支持该数据类型的运算操作。不同的数据类型是不可以进行运算操作。

a=1
b=2
c=a+b           # 两个变量都是int类型，之间可以相互转换
d='2'+a         # 前者是字符串类型，后者是int类型，之间不可以相互转换，会报错

1.2.5 对象的内存示意图

python程序运行时会在内存中创建各种对象（位于堆内存中），通过赋值语句可以将对象绑定到变量（位于栈内存中），从而通过变量引用对象进行各种操作。多个变量可以引用同一个对象。如果一个对象不在被任何有效有效作用域中的变量引用，则会通过自动垃圾回收机制收回对该对象占用的内存。

对象=确定内存空间（堆内存）+存储在这块内存空间的值（栈内存）

# 交换两个变量的示例以及相应的对象的示意图
a=123           # a指向值为123的int型实例对象
b=456           # b指向值为456的int型实例对象
t=a             # 变量t和a一样，指向（引用）对象实例123
a=b             # 变量a和b一样，指向（引用）对象实例456
b=t             # 变量b和t一样，指向（引用）对象实例123

1.2.6 对象的值比较和引用的判定

通过 == 运算符可以判断两个变量指向对象的值是否相同；通过 is 运算符可以判断两个变量是否指向同一个对象,即两个id是否相同

x='abc'         # x指向值为'abc'的字符串类型对象
y='abc'         # y指向值为'abc'的字符串类型对象
x==y            # 输出：true
x is y          # 输出：true
# == 相同，id不同的情况
x=[1,2,3]       # x指向值为[1,2,3]的列表类型对象
y=[1,2,3]       # y指向值为[1,2,3]的列表类型对象
x==y            # 输出：true 两个变量指向对象的值都是[1,2,3]
x is y          # 输出：false 两个变量分配的内存地址不一样，id不一样

1.2.7 可变对象和不可对象

python3对象可以分为不可变对象和可变对象。

不可变对象一旦创建，其值不能被修改，如果对原对象进行修改，就需要申请一片新的内存空间进行存储新的值，因为原来的内存地址是不可修改的，新的内存地址存储新对象；可变对象的值可以被修改，原对象可以在原内存地址上进行修改，无需创建一片新的内存地址。

不可变对象：整型（int)、浮点型（float）、复数（complex），布尔（bool）、字符串（str）、元组（tuple）

可变对象：列表（list)、字典（dict)、集合（set)

# 不可变对象
a=1         # a指向值为1的整数（int）数据类型对象
id(a)       # a的内存地址(id)为 1833444075824
b=1         # b指向值为1的整数（int）数据类型对象
id(b)       # b的内存地址(id)为 1833444075824
a=a+1       # 变量a加1后，将表达式的值重新赋值给变量a
id(a)       # a的内存地址(id)为 1716666067280 ，原来a=1的内存地址不再被使用，自动回收原先内存地址
​
# 可变对象
c=[1,2,3]       # c指向值为[1,2,3]的列表(list)类型对象
id(c)           # c的内存地址(id)为 1716674412864
d=[1,2,3]       # d指向值为[1,2,3]的列表(list)类型对象
id(d)           # d的内存地址(id)为 1716674413248 和变量c的id不一样
c.append(4)     # 变量c添加一个元素4
id(c)           # c的内存地址(id)为 1716674412864

通俗的说：不可变是指a的内存地址不能发生改变，内存地址为 1833444075824 的值在没有被垃圾回收之前一直都是1（b的值和a一样，所以b的内存地址和a一样），不能改变。当a的值发生改变（对原变量进行操作后），变量a将开辟一个新的内存地址为 1716666067280，而这个内存地址的值为2。原来a=1的值和内存地址将被python的垃圾回收机制给自动回收。

可变是指在进行创建时两个列表时，虽然两个列表的值相同，但是内存地址并不相同，实则两个列表开辟了两个内存地址，具有同样值的对象是不同的对象，即在内存中保存了多个同样值的对象，地址值不同。在对变量c进行操作的时候（增加一个元素4）时，列表的内存地址并没有发生改变，只是修改了变量c的值。

1.3 标识符及其命名规则

1.3.1标识符

标识符是变量、函数、类、模块和其他对象的名称。标识符的第一个字符必须是字母、下划线('_'),其后的字符可以是字母、下划线或数字，python的标识符是区分大小写的。一些特殊的名称，例如，if、for等作为python语言的保留关键字，不能作为标识符。

a_int、a_float、str1、func1 # 都是正确的变量名
99var、for、it's ok # 错误的变量名
# 避免使用双下划线开始和结尾的名称，__init__具有特殊意义
# 避免使用python预定义标识符作为自定义标识符名，如：dict、int、float等具有特殊意义的标识符

python3中的保留字

False       class       from        or
None        continue    global      pass
True        def         if          raise
and         del         import      return
as          elif        in          try
assert      else        is          while
async       except      lambda      with
await       finally     nonlocal    yield
break       for         not

python命名规则

类型	命名规则	举例
模块/包名	全小写字母、简单、有意义、如果需要可以使用下划线	math、sys
函数名	全小写字母，可以使用下划线增加阅读性	foo()、my_foo()
变量名	全小写字母，可以使用下划线增加阅读性	age、my_var
类名	驼峰命名法。多个单词组成名称，每个单词除第一个字母大写外其他字母均小写	MyClass
常量名	全大写字母，可以使用下划线增加阅读性	LEFT

1.3.2 变量和赋值语句

计算机程序通常用于处理各种类型的数据（即对象），不同的数据属于不同的数据类型，支持不同的运算操作。计算机程序处理的数据必须要放在内存中，通过访问这些数据的内存地址来访问这些数据。

对象：是某个类（类型）的实例，对象由唯一的id标识。

变量：对象可以通过标识符来引用，对象引用即指向具体对象实例的标识符。

变量的声明和赋值用于把一个变量绑定到某个对象

（1）变量名=字面量或表达式

x=0;y=0;z=0     # 变量x、y和z均指向int对象0
str1='abc'      # 变量str1指向值为'abc'的str类实例对象
a               # 报错，变量a未声明和定义

（2）链式赋值语句 变量1=变量2=表达式，链式赋值用于多个变量赋同一个值

x=y=123         # 变量x和y均指向int对象123
x               # 输出：123
y               # 输出：123

（3）复合赋值语句(最常用)

运算符	含义	举例	等效于
+=	加法赋值	sum+=1	sum=sum+1
	字符串拼接	s+='foo'	s=s+'foo'
-=	减法赋值	count-=1	count=count-1
*=	乘法赋值	x*=y+5	x=x*(y+5)
/=	除法赋值	x/=y-3	x=x/(y-3)
//=	整除赋值	x//=2	x=x//2
%=	取模赋值	x%=2	x=x%2
**=	幂赋值	x**=2	x=x**2
<<=	左移赋值	x<<=y	x=x<<y
>>=	右移赋值	x>>=y	x=x>>y
&=	按位与赋值	x&=y	x=x&y
|=	按位或赋值	x |=y	x=x|y
^=	按位异或赋值	x^=y	x=x^y

python后面几个赋值与JavaScript的语法相似 见JavaScript语法 第三章 - 食尸之鬼 - 博客园 (cnblogs.com)

i=1         # 变量i指向int对象1
i+=1        # 先计算表达式i+1的值，然后创建一个值为2的int对象，并绑定到变量i
i           # 输出：2
i*=3        # 先计算表达式i*的值，然后创建一个值为6的int对象，并绑定到变量i
i           # 输出：6

（4）序列解包赋值 将序列数据类型解包为对应相同个数的变量

a,b=1,2         # 变量a指向int对象1，变量b指向int对象2
a               # 输出：1
b               # 输出：2
​
# 如果只解包部分值，则可以采用特殊变量'_'
*_,a,_=['123','345','456','678']    # '*'表示不确定的前面省略多少个，'_'表示省略的内容
a       # 输出：'456'，前面由*_表示前面所有的值进行省略，a在倒数第二个位置（a,_),最后一个数省略，所以a为'456'

1.3.3 删除变量和常量

删除变量 使用del语句删除不在使用的变量

x=1     # 变量x指向int对象1
del x   # 删除变量x
x       # 报错：变量x未声明和定义

常量 使用约定，全大写字母（可以使用下划线增加阅读性)表示常量名

PI = 3.14       # 浮点类型常量PI
E = 2.8         # 浮点类型常量E

1.4 表达式和运算符

1.4.1 表达式的组成

表达式是可以计算的代码判断，由操作数和运算符构成。操作数、运算符和圆括号按照一定的规则组成表达式。表达式通过运算后产生运算结果，返回结果对象。运算结果对象的类型由操作数和运算符共同决定。运算符包括+、-、*、/等。操作数包括文本常数（没有名称的常数值，例如'abc'，1）、变量（i=123）、类的成员变量/函数（math.pi)等，也可以包含子表达式。

import math         # 导入math模块
a,b=2,10            # 用序列解包赋值法，变量a指向int对象1，变量b指向int对象2
a+b                 # 输出：12 表达式操作

1.4.2 表达式的书写规则

python表达式遵守下列书写规则：

（1）表达式从左到右在同一个基准上书写，例如：数学公式 a的平方加b的平方应写成 a ** 2+b ** 2

（2）乘号不能省略。例如,数学公式ab（表示a乘以b）应写为a*b

（3）括号要成双出现，而且只能使用圆括号，圆括号可以嵌套使用

# 例如 数学表达式：1/2*sin[(a(x+1)+b)]写成python
math.sin(a*(x+1)+b)/2

1.4.3 python 运算符

运算符	描述
lambda	Lambda 匿名函数表达式
or	布尔“或”
and	布尔“与”
not x	布尔“非”
in、not in	成员检测，检测前面一个的数据是否在后面数据类型的里
is、not is	同一性质检测，检测前面一个数据和后面一个数据是否相同
<、<=、>、！=	比较
|、^、&	按位或、按位异或、按位与
<<、>>	移位

1.5 python语句

1.5.1 python语句

语句是python程序的过程构造块，用于定义函数、定义类、创建对象、变量赋值、调用函数、控制分支、创建循环等。python常用语句分为简单语句和复合语句。

简单语句：表达式语句、赋值语句、assert语句（断言语句）、pass语句、del语句、return语句、yield语句、raise语句、break语句、continue语句、import语句、global语句、nonlocal语句

复杂语句：if语句、while语句、for语句、try语句、with语句、函数定义、类定义

# 输入圆的半径r，计算并输出圆的周长和面积
import math         # import语句，导入math模块
r=float(input("请输入圆的半径"))       # 赋值语句：输入圆的半径r，并转换为float数据类型
p=2*r*math.pi                        # 赋值语句：计算圆的周长
s=r**2*math.pi                       # 赋值语句： 计算圆的面积
print('圆的周长',p)                   # 表达式语句：输出圆的周长 
print('圆的面积',s)                   # 表达式语句：输出圆的面积 

1.5.2 python语句的书写规则

python语句的书写规则：

（1）使用换行符分隔，在一般情况下一行一条语句

（2）从第一行开始，前面不能有任何空格，否则会产生语法错误

（3）反斜杠（ \ )用于一个代码跨越多行的情况，如果语句太长，可以使用续行符（ \ ),同时三行引号定义的字符串(""".....""")可以放在多行，而不必使用续行符

（4）分号（；）用于在一行书写多条语句

    print(123)  # 报错：IndentationError: unexpected indent 前面有空格
print(123)      # 输出：123
print("你好\
世界")          # 输出：你好世界
print("""123
234
456""")         # 输出：123
                #       234
                #       456
a=0;b=0;c=0     # 变量a、b和c均指向int对象0

1.5.3 符合语句及其缩进书写规则

由多行代码组成的语句称为复合语句。复合语句（条件语句、循环语句、函数定义和类定义）由头部语句和构造题语句块组成。构造体语句块由一条或多条语句组成。复合语句和构造体语句块的缩进书写规则。

（1）头部语句由相应的关键字（例如for)开始,，构造体语句块则为下一行开始的一行或多行缩进代码

sum=0
for i in range(1,11):
    sum+=sum+i
    print(i,end='')             # 输出：1 2 3 4 5 6 7 8 9 10
print(sum)                      # 输出：55

（2）通常缩进是相对头部语句缩进4个空格，也可以是任意空格，但同一构造体代码块的多条语句缩进的空格数是一致的。如果语句不缩进，或者缩进不一致，会导致编译错误。

（3）如果条件语句、循环语句、函数定义和类定义比较短，可以放在同一行

for i in range(1,11): print(i,end='')

1.5.4 注释语句和空语句

注释语句

python注释语句以符号' # '开始，到行末结束。python注释语句可以出现在在任何位置。python解释器将忽略所有的注释语句，注释语句不会影响程序的执行结果。良好的注释可以帮助用户阅读和理解程序

# 打印'hello world!'
print('hello world!')       # 输出：hello world

空语句

如果要表示一个空的代码块，可以使用pass语句

def no_thing():
    pass        #定义一个函数no_thing，但函数体部分暂时还没有完成，又不能空着不写内容，因此可以用pass来替代占个位置

1.6 函数和模块、类和对象

1.6.1 函数的创建和调用

python语言中包括许多内置的函数，例如print()、max()等，用户也可以自定义函数。函数是可以重复调用的代码块，使用函数可以有效的组织代码，有效的提高代码重用率。

python使用复合语句def创建函数对象，其语法为

def 函数名[形参列表]：
    函数体
函数名([实参列表])
# 创建函数时可以声明函数的参数，即形式参数，简称形参；在调用函数时需要提供函数需要的参数的值，即实际参数，简称实参
# 函数可以使用return返回值。无返回值的函数相当于其他编译语言中的过程
​
# 例如：
def sayHello():                     # 创建函数对象sayHello
    print('hello world!')           # 函数体
sayHello()                          # 输出：hello world！ 调用函数 sayHello() 

1.6.2 函数API

python语言中提供了海量的内置函数、标准库函数、第三方模块函数、使用这些函数的关键是了解调用方法，函数的调用方法由应用程序编程接口(API)确定。

模块	函数调用方法	功能描述
内置函数	print(x)	输出x
	abs(x)	x的绝对值
	type(o)	o的类型
	len(a)	a的长度
python标准库math模块中的函数	math.sin(x)	x的正弦
	math.cos(x)	x的余弦
	math.sqrt(x)	x的平方根

a='123'     
type(a)         # 返回对象a所属的数据类型。输出：<class 'str'>
len(a)          # 返回字符串a的长度。输出:3
​
#标准库模块调用
# 方法一
import math
math.sin(1)             # 输出：Π/2
# 方法二
from math import sin
sin(1)                  # 输出：Π/2

1.6.3 创建类对象

类和对象是面向对象编程的两个主要方面。python使用复合语句class创建类对象，其语法格式如下：

class 类名：
    类体      # 可以定义属于类的属性、方法（def函数）
​
# 基于类对象可以创建其实例对象，然后访问其方法或属性
an=类名（参数列表）
an.对象方法  或 an，对象属性
​
# 例如
class Person(self):                 # 定义类Person
    def sayHello(self):             # 定义类Person的函数sayHello()
        print('hello world!')
p=Person()                          # 创建对象
p.sayHello()                        # 调用对象的方法 输出：hello world！