[Python知识库]python语法的学习

一.数据类型

1.数字类型

（1）在Python中浮点类型只有单精度float

（2）复数类型（其实就是数学中开平方的那个东西）

complex1 = 22 + 12j
print('complex1 =', complex1)			#complex1 = (22+12j)
print('复数 complex1 中的实部为：', complex1.real)	#复数 complex1 中的实部为： 22.0
print('复数 complex1 中的虚部为：', complex1.imag)	#复数 complex1 中的虚部为： 12.0

complex_demo1 = complex(22)  		# 将数字 22 转换为复数
print('complex_demo1 =', complex_demo1)	#complex_demo2 = (22+0j)

complex_demo2 = complex('33-22j')	 	#将字符串转换为复数，字符串在+或-的周围（前后）必须不能有空格。
print('complex_demo2 =', complex_demo2)	#complex_demo2 = (33-22j)

2.判断是什么类型的数据

type(a1)

?print('complex1 的类型为：', type(complex1))

3.string类型

python中单引号和双引号没有区别，都表示字符串

?下面是常用函数的表

? ? string常用函数了解一下，具体用到可以百度。下面是具体的用法

a = 'Hello','LXX'
b = 'Hello''LX'
c,d= 'Hello','LXX'
print(a)    #('Hello', 'LXX')
print(b)    #HelloLXX
print(c,d)  #Hello LXX
print(c+d)  #HelloLXX
#字符串切片，从字符串中提取子串，可指定两个索引：第一个字符的索引；要提取的最后一个字符的索引加 1
print(a[0:-1])  #('Hello',)
print(b[0:-2])  #Hello
print(c[0:])  #Hello# 省略字符串的终止索引，Python 会假设你要提取到字符串末尾。

print(c*2,d*2)#各输出两次,HelloHello LXXLXX

print('Hello,\nLXX')#带有回车
print(r'Hello,\nLXX')#加了r后转义字符失效
print(b[0],b[-1])   #负数索引是从右向左，-i表示倒数第i个，H X
#Python字串符是不可以被改变的，如果向一个指定索引赋值，将会错误

print(ord('1')) #返回对应字符的ASCll数值，或者Unicode值

def codesum1(s):
    for c in s:
        print(c)
    for i in range(len(s)):
        print(s[i])
num=1
snum=str(num)    #str函数是将数值类型转换成string类型
print(type(snum))

4.列表:List类型

在Python中，复合数据类型分别有三种：Tuple（元组）、Set（集合）与List（列表）

? ? ? ? 下面是List的常用函数

????????下面 是List的用法

s1 ='asas'
name=list(s1)   #将字符串或者元组转换为列表
name[1:]=list(s1)   #分片赋值，可以使用与原序列不等长的序列将分片替换
print(name)

a = ['a','b','c',3] #创建两个列表
b = [4,'love','l','l',',','never','change']
print(a,b)      #['a', 'b', 'c', 3] [4, 'love', 'to', 'l', ',', 'never', 'change']
print(b[1:7:2]) #['love', 'l', 'never']
#参数1是起始的索引，默认为0；参数2是结尾的索引，默认是列表最后一位；参数3是步长，默认是1，当步长是负值时返回原序列的倒序，如[::-1]返回原序列倒序。
print(b[1:7],b[2])   #['love', 'to', 'l', ',', 'never', 'change'] l

a.append(347)       #添加元素:在列表末尾添加新数值
a.insert(2,2)       #插入元素：把元素插入到指定位置
print(a)            #['a', 'b', 2, 'c', 3, 347]

a[2:2]=['w22','e22']    #2个参数相等，则是从参数1中插入数据，参数不等,则是覆盖
print(a)                #['a', 'b', 'w22', 'e22', 2, 'c', 3, 347]
a[0:3]='A','B','C'      #元素替换，直接赋值给对应的索引位置
print(a)                #['A', 'B', 'C', 'e22', 2, 'c', 3, 347]
a[1:2]=[]           #插入一个空序列，a[1]到a[2-1]都是空的
print(a)            #['A', 'C', 'e22', 2, 'c', 3, 347]
a[2]=[]             #给a[2]一个空数列，移除a列表中指定索引数据
print(a)            #['A', 'C', [], 2, 'c', 3, 347]

print('a列表数据个数:',len(a))  #len()函数用于统计列表数据个数,a列表数据个数: 5

a.clear()           #清空列表
a.extend(b)         #扩展列表，追加多个值,与append的区别，如果append用列表追加，则列表会作为一个元素添加
# a.extend((4,5,6))  # 列表末尾添加元祖
# 1.append() 添加的是元素「引用」，而 extend() 添加的是元素的「值」
# 2.append() 可以添加「任意类型」元素，而 extend() 只能添加「序列」
a.pop()             #pop，移除，默认最后一个元素。可以加序号index指定移除
a.pop(0)            #x= list1.pop(0),x是返回的被删除的值
print('##')
print(a)            #['love', 'l', 'l', ',', 'never']

print(a.count('l')) #2,返回某个值在该列表出现的次数
print(a.index('l')) #1,找出第一个匹配该值的索引index,没有找到会报错
a.remove('l')      #找到指定元素删除只删除第一个出现的元素，,没有找到会报错
#remove可以删除【对象类型】元素，包括列表类型和数组类型
print(a)            #['love', 'l', ',', 'never']

del a[1:3]          #删除元素
print(a)            #['love', 'never']
a.reverse()         #反向列表中元素
print(a)            #['never', 'love']
print(max(a),min(a))       #返回列表元素最大值never,返回列表元素最小值love


cat = ['fat', 'black', 'loud']  #多重赋值
c1, c2, c3 = cat                #ci分别对应cat中的第i个
print(c1)

e1=[a,cat]              #生成一个嵌入式列表,下面也是一样
e2=a.append(cat)        #append函数添加的是地址，当被添加的列表发生变化时，添加后的列表也会同步变化
print(e1)               #[['love', 'never', ['fat', 'black', 'loud']], ['fat', 'black', 'loud']]
cat.append('a')
print(e1)               #[['love', 'never', ['fat', 'black', 'loud', 'aaaaa']], ['fat', 'black', 'loud', 'a']]

e3=e1                   #=是直接赋值，2个列表是等价的，修改其中任何一个列表都会影响到另一个列表。
eee = e1[ : ]           #采用切片就没事儿返回包含原列表所有元素的新列表
e3.append('0')
eee.append('1')
print(e3,eee)            #e3和e1的内容一样,eee和e1的内容不一样

e4=e1.copy()            #浅拷贝，只拷贝第一层, 浅拷贝后e1的变动可能影响e4的值（第二层改变）
import copy as cp
e5=cp.deepcopy(e1)       #深拷贝，拷贝所有内容，深拷贝后e1的任何变动不会影响e5
e1[2]='1'
e1[0][0]=10
print(e4)               #[[10, 'love', ['fat', 'black', 'loud', 'a']], ['fat', 'black', 'loud', 'a'], '0']
print(e5)               #[['never', 'love', ['fat', 'black', 'loud', 'a']], ['fat', 'black', 'loud', 'a'], '0']
# insert同样存在 「列表同步」问题，改为 「深拷贝」即可
a = [1,2,3]
e1.insert(2, a)  # 添加列表a,换成深拷贝就不会出问题cp.deepcopy(a)
a.append(4)  # 列表a发生变化
print(e1)  # 列表同步发生变化

#sort排序只能对纯数字或者纯字符串的列表排序，整型和浮点型可以相互转换就可以排序，当元素之间的类型不能够互相转换时，例如整数和字符串就会报错
#sort排序，2个参数，key，reverse
# key参数指的是为列表的元素一一标记权值，并按照元素所对应的权值来排序元素。key=函数名，该函数的返回值作为元素的权值大小。
# reverse 默认升序，=True是降序
a = [(4, 2), (3, 2), (4, 4), (2, 4)]
a.sort(key=len,reverse=True)    #根据字符串长度排序

a.sort(key=lambda i:i[1])   #利用lambda表达式，按照第2个元素进行升序排序
def cmp(a, b):  # 自定义比较函数
    if(a[0]==b[0]):
        return b[1]-a[1]
    return a[0]-b[0]
#当结果为小于时，返回一个负数；当结果为相等时，返回0；当结果为大于时，返回一个正数。根据返回数的正负，确定2者之间的顺序

A = [(4, 4), (4, 3), (2, 4), (4, 5), (3, 3)]
import functools
A.sort(key=functools.cmp_to_key(cmp))   #Python3的functools包提供了cmp_to_key函数，可以将用户自定义的cmp函数转化为可以被可选参数key接收的对象。
#A.sort(key=functools.cmp_to_key(lambda x,y: x[0]-y[0]))
print(A)        #[(2, 4), (3, 2), (4, 2), (4, 4)]

5.

二.用到的需要了解的

1.python中的函数段，def

def Loveyou1314(s1):
	print('LXX'+s1)

Loveyou1314('我喜欢你，不知你可不可以做我女朋友')

2.lambda匿名函数

（1）lambda是匿名函数，但是可以命名，名字在等号左边

? ? ? ? <函数名>=lambda<参数>:<表达式>

等价于 def <函数名>(<参数>):

? ? ? ? ? ? ? ? <函数体>

? ? ? ? ? ? ? ? return <返回值>

（2）lambda只能包含一个表达式，不能包含复合语句

f = lambda x, y, z: x+y+z  #f是表达式的名字
print(f(1,2,3))  #像函数一样调用

（3）lambda的主体是一个单独的表达式，不是语句也不是一个代码块
?

x = (lambda a = "fee", b = "2", c = "3" : a + b + c)
print(x("acb")) #acb23

3.python导入库的几种方法

(1)将整个模块导入，格式为：import modulename

#import copy
import copy as cp    #as后面是指定的别名
e1=[1]
e5=cp.deepcopy(e1)

模块是指一个可以交互使用，或者从另一Python 程序访问的代码段。
只要导入了一个模块，就可以引用它的任何公共的函数、类或属性。
用import语句导入模块，就在当前的名称空间(namespace)建立了一个到该模块的引用.
这种引用必须使用全称，也就是说，当使用在被导入模块中定义的函数时，必须包含模块的名字。

(2)从某个模块导入某个、多个、全部函数，格式为：

from modname import funcname

from modname import fa, fb, fc

from modname import *

#modname中函数名可以直接用，函数前不用加模块的名字.

与第1种方法的区别：funcname 被直接导入到本地名字空间去了，所以它可以直接使用，而不需要加上模块名的限定。* 表示，该模块的所有公共对象(public objects)都被导入到 当前的名称空间，也就是任何只要不是以”_”开始的东西都会被导入。

如果模块包含的属性和方法与你的某个模块同名，你必须使用import module来避免名字冲突。

尽量少用 from module import * ，因为判定一个特殊的函数或属性是从哪来的有些困难，并且会造成调试和重构都更困难。

还可以百度搜一下，尝试通过代码自动导入缺失的库。

Python中的for循环详情_python_脚本之家 (jb51.net)

开发者涨薪指南

48位大咖的思考法则、工作方式、逻辑体系