【知识点 】Python基础-1

Python介绍

Python语言特点

• 是解释型语言

机器不能直接理解高级语言，需要把高级语言转换为机器能够理解的“机器语言”（汇编语言）

高级语言：结构语法更类似汉字或英文，比如常用的编程语言c、c++、python

编译型语言

先编译，生成文件，再运行，此后若不更改程序，就不需要再编译，运行速度快。

常用于开发操作系统、大型应用程序。

C/C++、Pascal都是编译型语言

解释型语言

不需要编译，程序运行一条，编译一次，运行速度稍慢。

适用于对速度要求不高，但是对平台兼容性有一定要求的程序。

Matlab、Python、JavaScript都是解释型语言

python解释器运行代码步骤

1、编译成所谓的“字节码”
2、将其发送至所谓的“虚拟机”

Python解释器通过将每一条源语句分解为单一步骤来将这些源语句翻译成一组字节指令

这些字节码可以提高执行速度：比起文本文件中原始的源代码语句，字节码的运行速度要快很多。

一旦程序编译为字节码，字节码便会被发送到Python虚拟机（Python Virtual Machine，简称为Python虚拟机）中执行。

• 高层语言：不用理会内存使用这些底层细节
• 可移植性好

Python发行时自带的标准库和模块在实现上也都尽可能的考虑到了跨平台的可移植性。

Python程序自动编译成可移植的字节码，这些字节码在已安装兼容版本的Python上运行的结果是一样的。

Python的标准实现是由可移植的ANSI C编写的

• 面向对象
• 可扩展（可用C/C++写，Python运行）
• 有丰富的库
• 规范性好（python语言结构优先，对格式要求比较高）

Python有关命令行

• 更新pip

python -m pip install -U pip	

• pip安装模块包

pip install 模块包名字 -i 国内镜像网站   

---------------------------------------------------------------------
清华：https://pypi.tuna.tsinghua.edu.cn/simple

阿里云：http://mirrors.aliyun.com/pypi/simple/

中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/ (比较好用)

华中理工大学：http://pypi.hustunique.com/

山东理工大学：http://pypi.sdutlinux.org/

豆瓣：http://pypi.douban.com/simple/

Python基本

变量

• 理解

是一个容器，可以存储数据

弱语言：声明变量的时候对类型要求不严格

python变量类型取决于后续赋予的具体数值

a = 12
b = 12.4
print(type(a), type(b))

<class ‘int’> <class ‘float’>

• 命名要求

1. 只能由字符、数字、下划线组成
2. 区分大小写
3. 第一个字符必须是字母
4. 不可使用关键字

• 命名规则

py文件名

小写字母，main.py

类名

大驼峰命名法，GetInfo

全局变量名

全部大写，且尽量为常量，NUMBER

普通变量：

全部小写，nameinfo

小驼峰类型，nameInfo【区别函数，推荐使用这个】

函数

全部小写+下划线，count_number()

数据类型及类型转换

• 常见数据类型

str、bool、int、float、list、tuple、dict、set、时间类型

• 特点：变量里面装入什么类型的数据，就是什么类型的变量，可以后续更改

a = 12, b = 12.4
print(type(a), type(b))

a = 12.5
print(type(a), type(b))

a = '123'
print(type(a), type(b))

a = True
print(type(a), type(b))

<class ‘int’> <class ‘float’>
<class ‘float’> <class ‘float’>
<class ‘str’> <class ‘float’>
<class ‘bool’> <class ‘float’>

字符串str

• 特点

字符串不可改变，即原字符串不可修改

所有关于字符串的操作方法，都不改变原有字符串，而是生成新的结果，保存在返回值里面

• 地址问题

a = '123'
b = a
c = '123'
d = '1234'
print(id(a))
print(id(b))
print(id(c))
print(id(d))

2443954096176
2443954096176
2443954096176
2443958582832

字符串变量大池子的假设，相同字符串对应的变量具有相同的地址，这也是为了节省空间

• 字符串有关函数

切片索引，部分输出

str[start:end:step]
step = 正数，从左往右取数
step = 负数，从右往左取数

查找字符串中的特定字符(串)，并返回位置信息

str.find(sub, begin, end)
# 从str[begin, end]中查找sub，并返回第一个sub出现的位置；若没有，返回-1

str.rfind()		# 对比find，查找方向相反
str.index()		# 对比find，查找失败后的返回值不一样，index返回ValueError、
str.rindex()	# 对比index，查找方向相反

判断字符串的结构特点，返回值都是bool类型

str.startwith(sub, begin, end)		# sub可以是字符或字符串
str.endwith(sub, begin, end)		# sub可以是字符或字符串
str.isalpha()
str.isdigit()
...

其他

https://www.runoob.com/python/python-strings.html

列表list

• 用途

用于存储任意数目、任意类型的数据集合。可更改列表里面的元素

• 创建

直接创建

a = ['1', 2, 'str']

list命令创建

list4 = list('hello')  			# list = ['h', 'e', 'l', 'l', 'o']

推导式创建

a = [x*2 for i in range(5)]		# a = [0, 2, 4, 8]

多维列表创建

a = [[], [], []]				# 引用 a[num][num]

• 列表基本操作

修改

listname[index] = newstr

遍历

for value in listname:
	print(value)

for index, num in enumerate(listname)
	print(index, num)

for value in listname:    
   print(value)

for index, num in enumerate(listname)    
	print(index, num)

列表合并

newlist = list1 + list2

• 列表处理函数

元组tuple

• 特点

不能修改元组内的值， 可以进行索引

• 创建

直接创建

t1 = ()   			#创建一个空元组
t1 = tuple() 		#空元组

t2 = (1,) 			#创建带有一个元素的元组，后面的逗号是必须的，否则无法区分是（）表达式还是元组
t2 = 1,

t3 = (1,4,True,'hello')

tuple命令创建

t5 = tuple('abc')

• 基本操作

连接

t1 = (1,2,3)
t2 = (4,5,6)
t3 = t1 + t2
print(t3) 			 #(1,2,3,4,5,6)

重复

print(t1 * 2)  		#(1,2,3,1,2,3)

切片

print(t3[0:3])  		#(1,2,3)
print(t3[3:])   		#(4,5,6)
print(t3[-1::-1]) (6,5,4,3,2,1)

成员运算符

print(3 in t3)  		#True
print(2 not in t3) 		#False

元素个数

print(len(t3))

最值

print(max(t3))  #6
print(min(t3))  #1	

字典dict

• 特点

键值一一对应关系

键唯一，值不唯一

• 创建

直接创建

d1 = {}  #空字典
d2 = {'name':'麻辣龙虾','taste':'美味'}

dict命令创建

d1 = dict()  #空字典

d3 = dict(a=1,b=2)
d4 = dict([('a', 1),('b', 2)])

dict+zip命令创建

key = ['1', '2', '3']
value = [1, 2, 3]
d = dict(zip(key, value))
# d = {'1':1, '2':2, '3':3}

fromkeys命令创建

a = dict.fromkeys(['key1', 'key2', 'key3'])		# a = {'key1':None, 'key2':None, 'key3':None}

• 操作

值访问

dictname['key']		失败，返回KeyError

键查找

dictname.get('key')

添加/修改值

dictname["key"] = newvalue
# 当指定的键不存在的时候，则表示添加。如果键已经存在，则表示修改value

删除pop

dictname.pop('key')

字典合并

dictname1.update(dictname2)

键/值输出

for key in dictname:
	print()

for value in dictname:
	print()

for key, value in dictname.items()
	print()

for key, value in enumerate(dictname)
	print()

成员操作

if('key' in dictname)

集合set

• 特点

不允许有重复元素，如果添加重复元素，则会自动过滤，可以进行交集、并集的运算

无序且无重复元素的数据结构

• 创建

直接创建

s1 = set()  		#空集合  不能是{}，这是字典
s2 = {1,2,3,4}

类型转换

print(set([30,40,50]))  				#通过列表创建
print(set((11,22,33)))  				#通过元组创建
print(set('hello'))     				#通过字符串创建  
print(set({'name':'大宝','age':20}))     #通过字典创建,得到一个键的集合

#注意：重复元素在set中会被自动过滤

• 操作

增加

s1.add(5)		# 添加不可变元素
s1.add((6,7))   # 添加元组元素，元组是可哈希的，也是不可变的
s1.add([6,7])   # ×不能添加列表，列表和字典都是不可哈希的，即都是可变类型数据


set.update(s) 	# s必须是可迭代的对象：列表、元组、字符串、字典
				# update会把列表、元组、字符串打碎添加到集合中
s1 = {1,2,3,4}
s1.update([5,6])
s1.update((7,8))
s1.update('hello')
s1.update({'1':10,'2':20})  

删除

set3 = {1,2,3,4,5,6}

set3.remove(4)   # 直接删除指定元素。如果元素不存在，则报错：KeyError


set3.pop()		 # 删除任意元素，并返回该元素的值

set3.discard(10) # 删除的元素不存在，不会报错

成员操作

print(2 in set3)  #True

并、交、差集

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
print(s1 | s2) 		 # 并
print(s1 & s2)  	 # 交集
print(s1 - s2)  	 # 差集

类型转换

input函数接收的数据，python统统视为str类型，就有了类型转换的需要

int()

# 注意：float类型的字符串不能直接转为int。需要先变为float，再变为int

int('12.5')  		# 错误
int(float('12.5'))	# 正确

float()

str()

bool()

0、‘’（空字符串） 转换后的结果为False，其余都是True

运算符

• 基本运算符

• 增强（赋值）运算符

• 比较运算符

仅同类型数据才能比较

数字之间比较

float和int可以相互比较

单纯比较数值大小

字符串相互比较

按照ASCLL码，逐位比较，直到第一个不相等的字符出现，比较其在ASCLL码中的大小顺序

• 逻辑运算符

• 同一运算符

• 位运算

位运算在OpenCV图像处理中应用的比较多

http://c.biancheng.net/view/2184.html

• 运算符的优先级关系

http://c.biancheng.net/view/2190.html

进制转换

https://blog.csdn.net/weixin_43353539/article/details/89444838

控制语句

• 条件语句

基本条件语句

if judge:
	expression1
---------可添加部分---------------
elif judge:
	expression
elif judge:
	expression
.......
---------可添加部分---------------
else:
	expression2

嵌套条件语句

• 循环语句

while循环

While judge:
	expression1
---------可添加部分---------
else:
	expression2
---------可添加部分---------	

for循环

for i in range():
	expression1
---------可添加部分---------
else:
	expression2
---------可添加部分---------

While、For的else部分，只有循环自然结束，才执行。如果有break，就不执行else的部分

• 终止循环语句

break：跳出当前层次循环

continue：跳出本次循环，循环继续

函数

基本函数

• 定义

def 函数名（[参数1],[参数2]....[参数n]）:
	函数体

• 参数

形参、实参

存在默认参数，必须放在普通参数的右边

def my_power(x,n=2):
   return (x) ** n

my_power(3)
my_power(4,0.5)

函数的参数可以是列表、字典、元组

若是对列表、字典参数进行删除操作，则原始列表、字典信息也相应改变

文档字符串

def test():
   """
             函数名：test
             功能：测试
             参数：无
             返回值：无
   """
	print("函数输出成功")
   
#使用__doc__属性查看文档字符串
print(test.__doc__)

• 可变参数： *args

赋值

a, *b, c = 1, 2, 3, 4, 5
print(a, b, c)

1 [2, 3, 4] 5 # 赋值情况下，多余的数以列表形式赋给可变参数

函数定义

def get(*args):				# 定义时候加*，表示加包，可以接受不限制数量的参数
   print(args)

函数调用

def get(*args):			
   print(args)
   
get([1, 2, 3, 4, 5])		# 若不拆包，没法直接对其输出结果操作
get(*[1, 2, 3, 4, 5])		# 调用加*，相当于拆包，把集合等数据拆开，方便操作
get(1, 2, 3, 4, 5)

([1, 2, 3, 4, 5],)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)

• 关键字参数： **kwargs （ key word arguments - 关键字参数）

定义

def get(** kwargs):     # 装包，字典类型
    print(kwargs)

调用

get()
get(name='我', number=3)
get(**{'name': '我', 'number': '3'})		# 拆包，方便调用

get({'name': '我', 'number': '3'})
get(*{'name': '我', 'number': '3'})

{}
{‘name’: ‘我’, ‘number’: 3}
{‘name’: ‘我’, ‘number’: ‘3’}
报错
报错

• 函数注释

def test(arg1, arg2):
    '''
        参数说明：
            arg1：第一个参数\n
            arg2：第二个参数
        
        函数功能：
            将arg1和arg2的值相加

        函数返回：
            返回两者相加的数值
    '''
    b = arg1 + arg2
    return b

a = test(1, 2)

• 函数嵌套

变量关系

a = 100
def outer():
    a = 200
    def inner():
        a = 300
        print('inner里面的a：', a)

    print('outer里面的a：', a)
    inner()

outer()
print('最外边的a：', a)

outer里面的a： 200
inner里面的a： 300
最外边的a： 100

对不可变类型变量的修改：nonlocal

a = 100
def outer():
    a = 200
    def inner():
        nonlocal a
        a += 1
        print('修改outer下属的a用nonlocal：', a)

    inner()

outer()

修改outer下属的a用nonlocal： 201

• 闭包

条件

1、嵌套函数
2、内部函数引用了外部函数的变量
3、返回值是内部函数

展示

a = 100
def outer():
    a = 200

    def inner():
        nonlocal a
        a += 1
        print('修改outer下属的a用nonlocal：', a)

    return inner

a = outer()
a()

递归函数

• 条件

必须有一个出口，防止无限调用

每次递归，都要保证向出口接近

• 示例

def test(i):
    if i == 5:
        return i
    else:
        return i + test(i+1)

r = test(1)
print(r)

15

匿名函数

• 特点

结构简单

常常配合高阶函数使用

• 定义

# lambda 参数: 返回值表达式
lambda a: a+1

• 调用

r =lambda a: a+1
print(r(1))

print( (lambda a: a+1)(1) )

2

2

高阶函数

函数调用函数

def pow(x, func):
    r = func(x)
    return r

result = pow(2, lambda x: x**2)
print(result)

常见使用高阶函数的系统函数

max() / min()

lists = [('Tom', 22), ('jack', 21), ('lily', 19), ('rouse', 20)]

print( max(lists) )
# 按照lists里面名字排序，找到最大值。默认数据的第一个元素

print( max(lists, key=lambda x: x[1]) )
# 按照lists里面年龄排序，找到最大值

(‘rouse’, 20)

(‘Tom’, 22)

sorted()

lists = [('Tom', 22), ('jack', 21), ('lily', 19), ('rouse', 20)]

print( sorted(lists, reverse=True) )
# 按照lists里面名字排序，并从大到小排序

print( sorted(lists, key=lambda x: x[1], reverse=True) )
# 按照lists里面年龄排序，并从大到小排序

[(‘rouse’, 20), (‘lily’, 19), (‘jack’, 21), (‘Tom’, 22)]
[(‘Tom’, 22), (‘jack’, 21), (‘rouse’, 20), (‘lily’, 19)]

filter()

lists = [('Tom', 22), ('jack', 21), ('lily', 19), ('rouse', 20)]

rr = filter(lambda x: x[1] > 20, lists)
# 过滤lists里面年龄小于20的，输出结果

print(list(rr))

[(‘Tom’, 22), (‘jack’, 21)]

map() 【取出某一列数据，并按照某一规则处理】

lists = [('Tom', 22), ('jack', 21), ('lily', 19), ('rouse', 20)]

lists = [('Tom', 22), ('jack', 21), ('lily', 19), ('rouse', 20)]

mm = map(lambda x: x[0], lists)
print(list(mm))

mm = map(lambda x: x[0].upper(), lists)
print(list(mm))

[‘Tom’, ‘jack’, ‘lily’, ‘rouse’]
[‘TOM’, ‘JACK’, ‘LILY’, ‘ROUSE’]

可变类型和不可变类型数据

• 可变和不可变类型

a = 100
print(id(a))
a = 90
print(id(a))

140727094223616
140727094223296

int类型，改变变量的值，其地址发生了改变，这种就是不可变类型

不可变类型：int、str、float、bool、tuple

可变类型：list、dict、set

不可变类型在函数内更改其数值需要使用global

a = 100
def test():
    # global a
    a = 5
    print(a)
test()

print(a)

# ----------------------------------------------------------

a = 100
def test():
    global a
    a = 5
    print(a)
test()

print(a)

5

100

5

5

引用和函数参数引用

• 分析引用次数

import sys

list1 = [1, 2, 3]
list2 = list1
list3 = list2

print(sys.getrefcount(list3))

del list1
print(sys.getrefcount(list3))

del list2
print(sys.getrefcount(list3))

4
3
2

sys.getrefcount()本身就相当于一次引用
如果把list3删除了，就不存在引用了，这块列表地址就回收了

• 不可变类型–函数参数引用

def test(n1):
    print('传入实参n的形参n1：', id(n1))
    n1 += 1
    print('改变数值后的形参n1：', id(n1))

n = 9
test(n)
print(n)
print('实参n：', id(n))

传入实参n的形参n1： 140725996361632
改变数值后的形参n1： 140725996361664
9
实参n： 140725996361632

• 可变类型–函数参数引用

def test(n1):
    print('传入实参n的形参n1：', id(n1))
    n1.append(5)
    print('改变数值后的形参n1：', id(n1))

n = [1, 2, 3, 4]
test(n)
print(n)
print('实参n：', id(n))

传入实参n的形参n1： 1492183643904
改变数值后的形参n1： 1492183643904
[1, 2, 3, 4, 5]
实参n： 1492183643904