python基本语言元素_Python 基本元素

0.基本语法

（1）单行注释用# 多行注释用3个双引号

（2）变量名字只能用字母，数字，下划线组成，并且不能用数字开头，python的关键字也不能使用

（3）等号左右需要加空格

（4）逗号后面要加上空格

(5) 注释行不能放在最末尾

1.基础函数（所有类型公用）

type() 看是什么类型

x[num] 切片 x[-1]最后一个 字典的【key】进行切片

x[a:b] 切片取 [a,b)

x[a:] [a开始到最后

x[:b]　开始到b）

x[::-1] 反转

x[0:-1] 第一个到倒数第二个的所有字符

列表可以用切片改变里面的值

s=slice(a,b,c) 提前把切片定义好 [a,b) 步长为c s.start =a s.stop = b s.step = c或 x[a,b,c]

len(x) 由多少个组成

input(str) 接收到的是字符串类型的

sum(list) 加总列表里的数字

max(a,b,c) 取最大值

** 字典内的值大小比较

people =[

{'name': 'alex', 'age': 1000},

{'name': 'wupei' , 'age':10000},

{'name': 'alex', 'age': 9000},

{'name': 'alex', 'age': 18},]print(max(people, key=lambda dic:dic['age'])) #{'name': 'wupei', 'age': 10000}

min(a,b,c) 取最小值

dir(x） x 可为方法名，以列表的形式输出x的属性

eval(str) 将字符串内的元素取出来 比如 ‘1+2’ 输出3

hash(str) 可hash的是指不可改变的类型，不论输入的长度有多长，输出的长度都是固定值, 无法根据hash值反推

字符串是什么,只要变量不变，得到的hash值都是一样的额

globals()　全局变量

locals()　　局部变量

__file__　　当前文件名

reversed(x) 反转

sorted(x)　　排序：不同类型不能排序， 本质就是在比较大小，不同类型之间不能比较大小

sorted(people,key=lambda dic:dic['age']）

type(x) 　　x 是什么类型

map(func,list)　　将列表中的元素作为参数传给 func 在发返回func的值 类似：functools.reduce()

map 装一个列表，依次处理列表中的因素， 最后还是一个列表，和原来列表中的顺序是一样的

functools.reduce() 把整题数据压缩一遍，得到一个最终的结果

filter(func,iterable) 将可迭代的对象一次用func进行筛选，

print(list(filter(lambda x:x.endswith('sb'),sb_list))) #['adysb', 'dfdesb', 'fefwsb']

print(string,sep(seperate=分割，默认是一个空格), end = 打印一行之后在结尾再加上点什么（默认为\n )

del var 　　　　　删除一些对象引用

2. 数字int 浮点数float complex复数（1+2j) （不可变）

int(x,base = n) （1）若x 为字符串，将字符串转换成数字 相类似的有str() bool()

（2）若x 为数字，就是将n 进制 的数，转换为10 进制

float(x)　　　　　　将x 转换到一个浮点数

complex(real [,imag]) 创建一个附属

num.bit_length() num的二进制至少用几位来表示

abs(num)　　　　 绝对值

round(x[,n])　　　返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。

sqrt(x)　　　　　 返回数字x的平方根

fabs(x)　　　　　 返回数字的绝对值，如math.fabs(-10) 返回10.0

floor(x)　　　　　返回数字的下舍函数 如4.9 =>5

bin(num)　　　　 转换为二进制值

hex(num)　　　　 转换为16进制值

oct(num)　　　　　转换为8进制值

divmod(a,b)　　　　a/b 取余数 相当于a%b

pow(a,b,c)　　　　a的b次方对c 取余

chr(num) 　　　　数字所对应的ascII 码 所对应的值

cell(x)　　　　　　取数字的上入整数， 如cell(4.1)=>5

exp(x)　　　　　　返回e^x

log(x)　　　　　　底为e

math.log(x[,base]) 　　底自己设

log10(x)　　　　　底为10

modf(x)　　　　　返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

ord(str)　　　　　 显示字符在ascII 码中所对应的位置

round(num,n)　　 四舍五入，保留n位小数

pow(x,y)返回 xy（x的y次方） 的值。 pow(x,y,z)返回 pow(x,y) %z

all(list) 　　　　　有假的布尔值存在 返回假 所有为真才为真 如果是空 也是true

bool() 　　　　　查看布尔值

3. 字符串str （不可变）

反斜杠\ 转义特殊字符，如果不愿意让反斜杠发生转义，可以在字符串前面加一个r

str(x) 　　　　将对象转换为字符串

repr(x) 　　　　 将对象转换为表达式字符串

eval(str)　　　　 用来计算在字符串中的有效Python表达式,并返回一个对象

chr(x)　　　　　 将一个整数转换为一个字符

ord(x)　　　　　 将一个字符串转换为它的整数值

大小写转换，字符替换

str.capitalize()　　首字母大写

str.casefold()　　 字母都变成小写，运用于其他字母，比如法语

str.lower()　　　　 变成小写

str.upper()　　　　变成大写

str.swapcase()　　 大小写转换

str.maketrans(a,b) 制作对应关系 str就是str ,不是只变量 返回一个字典

str.translate(str.maketrans(a,b)) 进行转换的实施

make_1 = "2366231"make= str.maketrans('123', 'abc')print(make_1.translate(make)) #bc66bca

bytes(str,encoding = 'utf-8') 把字符串转换成字节的形式

chr(num) 　　　　数字所对应的ascII 码 所对应的值

字符串位置（对齐与填充，分割)

str.center(n,str)　 一共n个位置，把名字放在中间, 其余用str 填充，str 只允许填充一个字符

str.zfill()　　　　　　右对齐，其余用0 填充

str.ljust() 　　　　　　左对齐 类似： str.rjust()

str.count(str2,a,b)　　　str2 在str 中出现几次　　从第a 位开始寻找，到第b 位结束

str.strip()　　　　　　　(1) 默认：去掉两边的空白 类似str.rstrip() 去掉左边空白 str.lstrip() 去掉右边空白

str.rstrip('xxxxx')　　　　去掉右边符合xxxx的东西

str.strip(str)　　　　　　只要找到子序列匹配成功都可以去掉 str.rstrip() str.lstrip() 一样

str.format(dict)　　　　　将str 中的{key} 用dict 中的value 替换

tempalte = 'i am {name}, age:{age}' #format 也可以用字典， 但是前面要加两个*

v3 = tempalte.format(**{"name": "adeline", "age": 10, "ds": 98})

test2 = 'you are {name4}, age {a4}'v2 = test2.format_map({"name4": 'ales', "a4": 19})

# you are ales, age 19

str.expandtabs(n)　　　　填补空格，用于制作表格 \t 制表符 \n 另起一行

print(name.isalnum())

s = '1234567\t8\t9'

print(s.expandtabs(6)) # 先找6个在找6个 找到\ 8前面出现了5个空格,9前面也5个空格 若前面不到6个到\t 会补空格 用于制作表格

# 1234567 8 9

表格制作：

s = "" #s = 空字符串 以达到无限循环的目的

whileTrue:

yhm= input("请输入用户名")

mm= input('请输入密码')

email= input('请输入邮箱')

yhm1= yhm[0: 19]

mm1= mm[0: 19]

email1= email[0:19]

test= '{0}\t{1}\t{2}\n'test1=test.format(yhm1, mm1, email1)

b= test1.expandtabs(10)

s= s +bif yhm == "q" or mm == 'q' or email == 'q' or yhm == 'Q' or mm == 'Q' or email == 'Q':break

print(s)

str.join(str2)　　　　　每个字符之间用str/填充　 str2也可以是元祖

china_join = "你是风儿我是啥"

print(line.join(china_join))

#你_是_风_儿_我_是_啥

join也可以用来拼接列表元素，前提是列表元素都是字符串

print(''.join(list(name)))

str.partition(str2)　 以str2 将str 分隔成3份 包含自己 (永远返回元祖，里面3个字符串） 左往右

str.rpartition(str2) 　 以str2 将str 分隔成3份 包含自己 (永远返回元祖，里面3个字符串） 右往左

str.split(str2,n)　　　　 以str2 分割 str 分割的结果不包含自己，返回的是列表， 不包含自己 n 为分割几次

n1, n2, n3 = str.split(str2, 2) 　　直接将分割后的值赋予给变量

str.splitlines(True)　　　自动按行分割， True 换行符还在， False 换行符不在 T/F 首字母要大写

str.replace(str2, str3,n)　　将str 中的str2 替换成str3 ,替换n 次

str.maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

str.translate(str2.maketrans（）) 按照后者进行转换

编码

str.encode('gb2312') 　　以gb2312编码对unicode对像进行编码

str.decode('gb2312')　　以gb2312编码对字符串str进行解码，以获取unicode

str.decode('utf-8')　　如果以utf-8的编码对str进行解码得到的结果，将无法还原原来的unicode类型

bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

元素寻找

str.endswith(str2)　　　str 是否以str2 结尾

str.startswith(str2)　　　str 是否以str2 开头 同样也可以用来检测是否已元祖里的元素开头，但不支出列表

choices = ('http:', 'https')

url= 'https://www.python.org'

print(url.startswith(choices)) #True

str.find(str2,a,b) 　　　在（a,b]区间从左往右找 ，str2 返回第一个找到的位置 没有的话返回错误提示 类似rfind

str.index(str2,a,b)　　　在（a,b]区间从左往右找 ，str2 返回第一个找到的位置 没有的话返回-1　　　　rindex

字符是否是....

str.isalnum() 　　　　判断是否只包含数字和字母

str.isalpha()　　　　 判断是否只包含字母或文字

str.isdecimal()　　 　判断是否只包含数字 用的最多

str.isdigit()　　　　　 判断是否只包含数字 可以识别特殊字符的数字 比如②

str.isnumeric()　　　　判断是否只包含数字 可以用来识别字节的数字 比如：二

str.isidentifier()　　　　判断是否是标识符（字母数字下划线）

str.islower()　　　　　　判断是否都是小写

str.isprintable()　　　　 如果包含了一些不可见的字符 值为false

str.isspace()　　　　　 判断是否全部是空格, 什么都没有也显示false

str.istitle()　　　　　　 是否是title 即每个首字母都是大写

str.islower()　　　　　　判断是否是小写

str.isupper()　　　　　　判断是否是大写

isinstance(a,b)　　　　 判断a, 是否是b 类型 与type相比 type不会认为子类是一种父类类型，但isinstance 会认为子类是父类的一种类型

字符串格式化

%s

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

%c

格式化字符及其ASCII码

%s

格式化字符串

%d

格式化整数

%u

格式化无符号整型

%o

格式化无符号八进制数

%x

格式化无符号十六进制数

%X

格式化无符号十六进制数（大写）

%f

格式化浮点数字，可指定小数点后的精度

%e

用科学计数法格式化浮点数

%E

作用同%e，用科学计数法格式化浮点数

%g

%f和%e的简写

%G

%f 和 %E 的简写

%p

用十六进制数格式化变量的地址

*

定义宽度或者小数点精度

-

用做左对齐

+

在正数前面显示加号( + )

在正数前面显示空格

#

在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')

0

显示的数字前面填充'0'而不是默认的空格

%

'%%'输出一个单一的'%'

(var)

映射变量(字典参数)

m.n.

m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

4. 列表list （可变）

列表可以用加号直接串联

a = [1, 2, 3, 4, 5]

a+ [6, 7, 8]#[1, 2, 3, 4, 5, 6, 7, 8]

list[a] = x　　　　　　　将列表的第a 个元素修改为x

list[4][3][2] 　　　　　　索引取值可以一直往里面找 比如是指第四个元素（列表）中的第三个元素（列表）中的

第二个

list(str)　　　　　　　　 字符串转换成列表，运用的是for 循环 数字不能for循环，所以也不能转换

list.append(x)　　　　 列表追加元素, append 是将后面的元素当做整体去追加

list.extend(x)　　　　　　追加到后面，extend 相当于是迭代把每个元素依次加到里面

list.clear()　　　　　　　清空列表

list.copy()　　　　　　　 浅拷贝

list.count(x)　　　　　　计算x 出现的次数

list.index(x,a,b)　　　　 找某个值的索引位置 a开始，b 结束

list.insert(n,x)　　　　　 在n位置 插入x

l = list.pop(n)　　　　　 删除第n位的数，l 为被删除的数， list变成了删除后的列表

list.remove(x)　　　　　 删除列表中的x，左边优先 ，直接把那个值给删掉

list.reverse()　　　　　 将当前的列表进行转向

list.sort(reverse = True)　将数字进行排序，True 是从大到小排

zip(list1,list2 )　　　　可以将多个列表、元组或其它序列成对组合成一个元组列表”

5.元祖 tuple（a,b,c,) （不可变）

tup2 = (20,) #类型是 tuple

tup2 = (20) #类型是int

(1)元祖与列表类似，是列表的二次加工

(2)元祖的一级元素不可修改, 但元祖里面的列表中的元素是可以修改的

(3)创建不允许修改的东西用元祖

(4)可以用+和*

zip(元祖1，元祖2） zip 互相组成元祖，不是一一对应 多出来的不生成元祖

print(list(zip(('a','n', 'c'),(1,2,3)))) #[('a', 1), ('n', 2), ('c', 3)]

tuple(x) 　　　　字符串或列表可以转换成元祖

tuple.extend(x) 添加元素

tuple[3][3][2] 　也可以一直往里面取值

enumerate(tuple,n)　　输出元祖的元素和序号 n 是指从什么序号开始 (列表也可以）

su = ('asd', 'sfaf', 'afs')for idx, elem in enumerate(su, 10): #后面指从什么时候开始 前面指 迭代的元祖

print(idx, elem)#10 asd#11 sfaf#12 afs

tuple.count(x)　　输出x出现的次数

tuple.index(x)　　index 获取某个值在元祖中出现的位数 从左往右

6.字典 dic （可变）

info = {"k1": "v1", "k2": "v2"} # 用逗号进行分割 "k1": "v1" ：键值对 key-value

字典的value 可以查任何值， （布尔值可以作为key 但是因为显示出来是1，0 所以不能跟10 重复，列biao不能作为key，元祖可以作为key 因为它不可以修改，字典不能作为字典的key

字典是无序的，用print 打印出来的值顺序可能会变

del dic[key] 　　删除字典里的键值对

for item in dic: 默认循环字典的key

dic.values()　　字典的的值

dic.items()　　 直接将键值对渠道

dic.fromkeys(a,b) 第一个参数作为key 第二个参数作为左右key 的value 复制过去

v = dict.fromkeys([1, 'sda', 'sd'],111)print(v)#{1: 111, 'sda': 111, 'sd': 111}

dic.get()　　　　根据key 获取值，不存在时， 可以指定默认值none

a = dic.pop(key,y) 若没有找到key 返回默认值y a为被删掉的key 所对应的value dic 为删减后的字典

dic.popitem()　　　这里不能加参数 ，所以随机删掉一个

k1, k2 =zidian.popitem()print(zidian, k1, k2)#zidian 的值为删掉后的字典#k1 为删去的key#k2 为删去的value

dic.setdefault()　　加入一个新的键值对 前面是k 后面是v 如果前面的k 存在就不设置了，并获取之前key的值

zi = {1 : 'sda', 2: "sdad", "sd": 'daa'}

z= zi.setdefault(3, 'wwww')print(zi, z)#{1: 'sda', 2: 'sdad', 'sd': 'daa', 3: 'wwww'} wwww

dic.update()　　 没存在的更新，已存在的覆盖

zi.update({1: 'dadqf', 5:'dsfsgr'})print(zi)

zi.update(se= 'sdada', sd = 'sdaa') #前面只能用字符，且不加引号

print(zi)#**kwargs 默认会把以上这种自动转成字典了 可以使用字典，但前面要加两个*#{1: 'dadqf', 2: 'sdad', 'sd': 'daa', 3: 'wwww', 5: 'dsfsgr'}#{1: 'dadqf', 2: 'sdad', 'sd': 'sdaa', 3: 'wwww', 5: 'dsfsgr', 'se': 'sdada'}

dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])#{'jack': 4098, 'sape': 4139, 'guido': 4127}

dict(sape=4139, guido=4127, jack=4098)#{'jack': 4098, 'sape': 4139, 'guido': 4127}

tel['Mary'] = 4127 #添加一个键值对

利用序列创建字典

“mapping ={}for key, value inzip(key_list, value_list):

mapping[key]= value”

dic.setdefault()

words = ['apple', 'bat', 'bar', 'atom', 'book']

by_letter={}for word inwords:

letter=word[0]

by_letter.setdefault(letter,[]).append(word)#{'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

collections 中的 defaultdict

words = ['apple', 'bat', 'bar', 'atom', 'book']

by_letter={}from collections importdefaultdict

by_letter=defaultdict(list)for word inwords:

by_letter[word[0]].append(word)#defaultdict(, {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']})

7. 集合 set （可变）

s = {1, 2, 4, 'fdfsdf', 'sdf'} 创建一个空集合 要用set() 函数来， {} 是用来创建空字典的

是可变类型

set()　　　　转变为集合

frozenset(s)　　转变为不可变集合

set.add(x) 只能增加一个值

set.clear() 清空集合

set.copy() 浅拷贝

set.pop() 只能随机删除

set.remove(x)　　可以有目的的进行删除，但不存在 ，会报错

set.discar(x)　　 可以有目的的进行删除，但不存在 ，不会报错

set2.intersection(set1) / set1 & set2 　　　　set1和set2 的交集

set1.union(set2)/set2 | set1　　　　set1和set2 的并集

set2.difference(set1)/set1 - set2　　　　　　 set1和set2 的差集

set1.symmetric_difference(set2)/set2 ^ set1 　　set1和set2 的补集 （先和在一起再减去共同的部分）set1不变

set1.difference_update(set2)　　　 set1和set2 的补集 （先和在一起再减去共同的部分） set1 自己变了

set1.isdisjoint(set2)　　　　　 set1和set2 是否有交集 返回布尔值

set1.update(set2)　　　　　　　　set1 更新为并集 　　set2 可以是元祖

set_f = frozenset(set3)　　　　设定一个不可变集合

a-b a和b的差集

a|b a和b的并集

a&b a和b的交集

a^b a和b 中不同时存在的元素

8.基本语句

（1）if elif else

(2) while continue break : 对于continue来说是终止当前循环，进行下次循环，对于break 来说是终止所有循环

(3）for x in a

(4) from x import a 导入

将整个模块导入 import A

从某个模块中导入某个函数,格式为 from A import somefunction

从某个模块中导入多个函数,格式为: from A import funcA, funcB, funcC

将某个模块中的全部函数导入， 格式为from A import *

后三种情况，运用函数时，直接写函数名即可，不用 A.函数名 来调用

（5）lambda ：匿名函数 快速定义单行函数

(6) 三元表达式 ： res = 'SB' if name == 'alex' else 'shuai' （'SB' 一元 if name == 'alex' 二元 else 'shuai'

三元） 　　　print(['鸡蛋%s' %i for i in range(10) if i >5])

（7）多行语句，可以用\来分行，也可以用"""...""",or, '''...''' 跨行 在[],{},()中的多行语句，不需要用反斜杠进行分行,

（8） 同一行显示多条语句， 用；分隔

9. 命令行参数 （在终端里面使用）

$ python -h 可以查看各个参数的信息