Python 语法-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_43124630/article/details/82531839

语法

文章目录

print("")

print ("Hello World")

Hello World

if else:

if a>b:
    print('Yes')
elif a==b:
    print('emmm')
else:
    print('No')

input

input(">>>>>>")

>>>>>>输入内容

input()

输入内容

元祖tuple

tuple（元组）被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（“a”,“b”,“c”）

列表list

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开。
里面可以存放各种数据类型比如：

list = [‘PH’, 123, Ture, (1,2,3,’wusir’), [1,2,3,’dongdong’,], {‘name’:’PH’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素，64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

list增

list = [1, 'a', 'b', 2, 3, 'a']
list.insert(0,55) #按照索引去增加
print(list) #[55, 1, 'a', 'b', 2, 3, 'a']

list.append('aaa') #增加到最后
print(list) #[1, 'a', 'b', 2, 3, 'a', 'aaa']

list.extend(['q,a,w']) #迭代的去增
print(list) #[1, 'a', 'b', 2, 3, 'a', 'q,a,w']

list删

list = [1, 'a', 'b', 2, 3, 'a']
l1st = list.pop(1) #按照位置去删除，有返回值
print(list) #a

del list[1:3] #按照位置去删除，也可切片删除没有返回值。
print(list) #[1, 2, 3, 'a']

list.remove('a') #按照元素去删除，只去除碰到的第一个，如果没有相应元素则会报错
print(list) #[1, 'b', 2, 3, 'a']

list.clear() #清空列表，但是列表本身依旧存在

list改

list = [1, 'sa','bi', 2, 3, 'a']
list[1] = 'dfasdfas'
print(list) #[1, 'dfasdfas', 'bi', 2, 3, 'a']，第二个元素被替换了

list[1:3] = ['a','b']
print(list) #[1, 'a', 'b', 2, 3, 'a']，第2、3个元素被替换了

list查
使用切片去查，或者使用循环去查。
**count **

a = ["q","w","q","r","t","y"]
print(a.count("q")) #2

index

用于从列表中找出某个值第一个匹配项的索引位置

a = ["q","w","r","t","y"]
print(a.index("r")) #2

sort

没有返回值，用于在原位置对列表进行排序

a = [5, 34, 1, 3, 999]
print(a.sort()) #None
a.sort()
print(a) #[1, 3, 5, 34, 999]

reverse

没有返回值，将列表中的元素反向存放

a = [2,1,3,4,5]
a.reverse() #他没有返回值，只能打印a
print(a.reverse()) #None
print(a) #[2, 1, 3, 4, 5]，没有变化

a.reverse()
print(a) #[5, 4, 3, 1, 2]，正常输出
a.sort() #他没有返回值，只能打印a
print(a) #[1, 2, 3, 4, 5]

字典dict

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
　　字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

dic = {'name':'Ph', 'age':20, }
print(dic) #{'name': Ph, 'age': 20}

dict增

dic = {'name':'Ph', 'age':20, }
dic['lis'] = ["a","b","c"] #添加 ['lis']:["a", "b", "c"]到dic中
print(dic)                 #{'age': 20, 'lis': ['a', 'b', 'c'], 'name': 'Ph'}

dic.setdefault('x',10)     #有键值对，不做任何改变，没有才添加
print（dic）               #{'lis': ['a', 'b', 'c'], 'age': 20, 'name': 'Ph', 'x': 10}

dict删

print(dic.pop('age'))   # 有返回值，删除后给出
                        # 若字典内没有这个键，则返回设置的返回值
print(dic.pop('没有的键',None))   # 返回None
print(dic) #{'name': 'Ph', 'lis': ['a', 'b', 'c'], 'x': 10}

print(dic.popitem())  # ('x', 10), 删除最后一个键值对并返回值，返回值是元祖，里面是删除的键值
print(dic) #{'name': 'Ph', 'lis': ['a', 'b', 'c']}

dic.clear() #清空字典，但是字典还是存在的

del dic['name'] #del可以删除键值对或者字典本身
del dic

dict改

dic = {'name':'Ph', 'age':20, }
dic1 = {"name":"Jibai", "weight":75}

dic.update(dic1) #把dic1的键值对添加到dic中
print(dic) #{'name': 'Jibai', 'age': 20, 'weight': 75}

dict查


print(dic.keys()) #dict_keys(['name', 'age'])，返回以键为内容的列表
print(dic.values()) #dict_values(['Ph', 20])，返回以值为内容的列表
print(dic.items()) #dict_items([('name', 'Ph'), ('age', 20)])，返回以键值对为内容的元祖

for i in dic:
    print(i)
for i in dic.keys():
    print(i) 
#name
#age
#二者打印的都是键

for i in dic.values():
    print(i) #Ph
             #20
#打印出值

for i in dic.items():
    print(i) #打印出列表，列表的元素是各个元祖，元祖内包含键值对
    #('name', 'Ph')
    #('age', 20)
for i, j in dic.items():
    print(i, j)
    #name Ph
    #age 20

print(dic.get("name1", "没有这个键")) #有name1键时返回值，没有则返回“没有这个键”

集合set

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。
集合最重要的两点：

去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
集合的创建

set1 = set({1,2,'zio'})
set2 = {1,2,'gaiz'}
print(set1,set2)  # {1, 2, 'zio'} {1, 2, 'gaiz'}

集合的增

set1 = {'zio','gaiz','build','crossz','exaid'}
set1.add('parado')
print(set1)

#update：迭代着增加
set1.update('ghost')
print(set1) #{'build', 'zio', 'parado', 'crossz', 'h', 'g', 'gaiz', 't', 'exaid', 'o', 's'}
set1.update('drive')
print(set1) #{'build', 'zio', 'i', 'parado', 'crossz', 'h', 'v', 'g', 'gaiz', 't', 'exaid', 'd', 'e', 'o', 's', 'r'}
set1.update([1,2,3])
print(set1) #{1, 2, 3, 'build', 'exaid', 'zio', 'd', 'h', 'o', 'crossz', 'v', 'g', 'r', 'e', 'i', 'gaiz', 't', 's', 'parado'}

集合的删

set1 = {'zio','gaiz','build','crossz','exaid'}

set1.remove('zio')  #删除一个元素
print(set1) #{'exaid', 'crossz', 'gaiz', 'build'}

set1.pop()  #随机删除一个元素
print(set1) #{'crossz', 'gaiz', 'build'}

set1.clear()  #清空集合
print(set1) #set()

del set1  # 删除集合
print(set1) #此时会报错，NameError: name 'set1' is not defined

集合的其他操作

交集（& 或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

并集（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}

print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

差集（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

反交集（^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

frozenset不可变集合，让集合变成不可变类型

s = frozenset('zio')
print(s, type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

深浅拷贝

赋值运算

lis1 = [1,2,3,['faiz', 'zio'],]
lis2 = lis1

lis1[0] = 111
print(lis1) #[111, 2, 3, ['faiz', 'zio']]
print(lis2) #[111, 2, 3, ['faiz', 'zio']]
lis1[3][0] = 'build'
print(lis1) #[111, 2, 3, ['build', 'zio']]
print(lis2) #[111, 2, 3, ['build', 'zio']]

对于赋值运算来说，lis1与lis2指向的是同一个内存地址，所以他们是完全一样的。

浅拷贝copy

lis1 = [1, 2, 3, ['zio', 'gaiz']]
lis2 = lis1.copy()

print(lis1, id(lis1)) #[1, 2, 3, ['zio', 'gaiz']] 2493432750728
print(lis2, id(lis2)) #[1, 2, 3, ['zio', 'gaiz']] 2493461478792
# 取lis1和lis2的内存地址以及所存内容

lis1[1] = 222 
print(lis1, id(lis1)) #[1, 222, 3, ['zio', 'gaiz']] 2493432750728
print(lis2, id(lis2)) #[1, 2, 3, ['zio', 'gaiz']] 2493461478792
# 给lis1[1]赋新的值后发现内存地址没有变化

lis1[3][0] = 'build'
print(lis1, id(lis1[3])) #[1, 222, 3, ['build', 'gaiz']] 2493432750664
print(lis2, id(lis2[3])) #[1, 2, 3, ['build', 'gaiz']] 2493432750664
# 给lis1[3][0]赋新的值后发现内存地址发生了变化

对于浅copy来说，第一层创建的是新的内存地址。
比如lis1[0], lis1[1], lis[2],
而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
比如lis1[3]

深拷贝deepcopy

import copy
lis1 = [1, 2, 3,['zio', 'gaiz']]
lis2 = copy.deepcopy(lis1)

print(lis1,id(lis1)) #[1, 2, 3, ['zio', 'gaiz']] 2420029990728
print(lis2,id(lis2)) #[1, 2, 3, ['zio', 'gaiz']] 2420028105352
# 取lis1和lis2的内存地址以及所存内容，和浅拷贝一样，lis1和lis2的内存地址不一样

lis1[1] = 222
print(lis1,id(lis1)) #[1, 222, 3, ['zio', 'gaiz']] 2420029990728
print(lis2,id(lis2)) #[1, 2, 3, ['zio', 'gaiz']] 2420028105352
# 修改lis[1]的内容，之后两者内存地址依旧不变

print(lis1,id(lis1[3])) #[1, 222, 3, ['zio', 'gaiz']] 2420029992072
lis1[3][0] = 'build'
print(lis1,id(lis1[3])) #[1, 222, 3, ['build', 'gaiz']] 2420029992072
print(lis2,id(lis2[3])) #[1, 2, 3, ['zio', 'gaiz']] 2420028105288
# 修改lis1[3][0]而不修改lis2[3][0]，发现二者直接不互相影响

对于深copy来说，两个对象是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。

字符串

拼接

字符串之间无缝拼接用+

print('qwe'+'rty')

output qwerty
使用逗号的话会有空格

print('qwe','rty')

索引
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

a = '12345678'
print(a[0]) #1
print(a[3]) #4
print(a[5]) #6
print(a[7]) #8

切片
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串。
原则是顾头不顾腚。

a = '12345678'
print(a[0:3]) #123
print(a[2:5]) #345
print(a[0:]) #默认到最后
print(a[0:-1]) # -1是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到最后一个元素
print(a[0:5:2]) #加步长 135
print(a[5:0:-2]) #反向加步长 642

foramt格式化

sora = "i am {name}, age {age}, really {name}".format(name="elfn", age=18)
print(sora)
# i am elfn, age 18, really elfn

sora = "i am {name}, age {age}, really {name}".format(**{"name": "elfn", "age": 18})
print(sora)
# i am elfn, age 18, really elfn

sora = "i am {:s}, age {:d}".format(*["elfn", 18])
print(sora)
# i am elfn, age 18

sora = "i am {:s}, age {:d}".format("elfn", 18) 
print(sora)
#["elfn", 18]

l=["elfn", 18]
sora = "i am {:s}, age {:d}".format('elfn',18)
print(sora)
# i am elfn, age 18

sora = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%},{}".format(15, 15, 15, 15, 15, 13.4512, 2)
print(sora)
# 1111,17,15,f,F, 1345.120000%,2

‘b’ - 二进制。将数字以2为基数进行输出。
‘c’ - 字符。在打印之前将整数转换成对应的Unicode字符串。
‘d’ - 十进制整数。将数字以10为基数进行输出。
‘o’ - 八进制。将数字以8为基数进行输出。
‘x’ - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
‘e’ - 幂符号。用科学计数法打印数字。用’e’表示幂。
‘g’ - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
‘n’ - 数字。当值为整数时和’d’相同，值为浮点数时和’g’相同。不同的是它会根据区域设置插入数字分隔符。
‘%’ - 百分数。将数值乘以100然后以fixed-point(‘f’)格式打印，值后面会有一个百分号。

如何在多个print的情况下不自动换行

print("输入内容", end="_")
print("输入内容", end="")
print("输入内容", end="!!")

output输入内容_输入内容输入内容!!

强制类型转换

int(被转换内容)
str(被转换内容)
......