您现在的位置是：首页 > Python

当前栏目

（一）Python基本语法元素

2023-02-18 15:50:07 时间

程序的基本编写方法

4）复数类型（python特有的数据类型）

序列

访问模式

程序的基本编写方法

输入

文件输入、网络输入、控制台输入、交互界面输入、内部参数输入等
输入是一个程序的开始

处理

处理是程序对输入数据进行计算产生输出结果的过程
处理方法统称为算法，它是程序最重要的部分
算法是一个程序的灵魂

输出

控制台输出、图形输出、文件输出、网络输出、操作系统内部变量输出等
输出是程序展示运算结果的方式

程序语法元素分析

程序的格式框架

1) 缩进

严格明确：缩进是语法的一部分，缩进不正确程序运行错误

所属关系：表达代码间包含和层次关系的唯一手段

长度一致：程序内一致即可，一般用4个空格或1个TAB

2) 注释

单行注释：以#开头，其后内容为注释

# 这是单行注释

多行注释：以'''开头和结尾

''' 这是多行注释的第一行
这是多行注释的第二行 '''

命名与保留字

1）变量

变量采用标识符(名字) 来表示，关联标识符的过程叫命名

可以使用等号(=)向变量赋值或修改值，=被称为赋值符号

2）命名

命名规则: 大小写字母、数字、下划线和中文等字符及组合

注意事项: 大小写敏感、首字符不能是数字、不与保留字相同

3) 保留字

Python语言有35个保留字(也叫关键字

保留字是编程语言的基本单词，大小写敏感

所有的保留字，如下表所示：

表一保留字

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

数据类型

1）整形

整形：int

2）浮点型

浮点型：float

3）布尔型

布尔型：bool

只有True和False，表示真假

4）复数类型（python特有的数据类型）

复数：complex

1.用实数加减（实数+j)来表示

a = 3-4j

2.用complex（）函数来表示

a = complex(3,-4)

序列

访问模式

正向递增：从0开始
反向递减：从-1开始

<	>
<=	>
==	!=

x in s	x not in s	s + t	s * n, n * s
s[i]	s[i:j]	s[i:j:k]	s[::-1]

enumerate()	reversed()	len()	sorted()
max()	sum()	min()	zip()

1）字符串

字符串：str

有引号引起来的就是字符串，单，双，三引号都行（与C有区别），具体代码如下所示：

s1 = "I'm a student"
print(s1)
s2 = "'hello " \
     "world'"
print(s2)
s3 = r'd:\test\a.txt'
print(s3)

运行结果如下所示

I'm a student 'hello world' d:\test\a.txt

类型说明符：

b	二进制，以2为基数输出数字
o	八进制，以8为基数输出数字
x	十六进制，以16为基数输出数字，9以上的数字用小写字母（类型符为X时用大写字母）表示
c	字符，将整数转换成对应的Unicode字符输出
d	十进制整数，以10为基数输出数字
f	浮点数，以浮点数输出数字
e	指数记法，以科学计数法输出数字，用e（类型符是E时用大写E）表示幂

常用格式说明符：

+m.nf	输出带符号（若正整数输出“+”号）的数，保留n位小数，整个输出占 m列（若实际宽度超过m则突破m的限制）
<	左对齐，默认用空格填充右边
0>5d	右对齐，用0填充左边，宽度为5
^	居中对齐
{{}}	输出一个{}

大体输出格式为：[对齐说明符][符号说明符][最小宽度说明符][.精度说明符][类型说明符]

实例如下：

age, height = 21, 1.758
print("Age:{0:^5d}, Height:{1:5.2f}".format(age, height))
#输出结果为  Age: 21  , Height: 1.76

字符串与输出形式：

Python中有多种输出方式，目前提供几种常见的输出形式，代码如下：

1.用format函数格式化字符串：

name = ['A', 'B', 'C', 'D', 'E',]
score = ['100', '106', '500', '10', '100']
for i in range(5):
    print('{:<8d}{:8s}{:8s}'.format(i, name[i], score[i]))
print('I get {:d}{{}}!'.format(100))

输出结果如下所示：

0 A 100 1 B 106 2 C 500 3 D 10 4 E 100 I get 100{}!

2.格式化字符串f-string

x, y = 3, 5.678
print(f"x = {x}, y = {y:.2f}")    #用F来表示也可以，如print(F"x={x}, y={y:.2f}")

输出结果如下所示：

x = 3, y = 5.68

除此之外，f-string还支持表达式和函数调用，代码实现如下：

x = 3
print(f"{x*4 + 5}")
s = 'Hello'
print(f'{s.lower()}')

输出结果如下所示：

17 hello

字符串的应用：

字符串有许多的方法提供给我们使用，可以让我们快速方便的解决一些问题，此处只展示一小部分方法的使用，代码如下所示：

#第一种做法
str = "abcdcba"
if (str == ''.join(reversed(str))):       #reversed方法用来逆序字符串，返回值是reversed类型                                          
    print('Yes')                          #join方法用来连接字符串，让reversed类型变成str类型
else:
    print('No')

#第二种做法
str = "abcdcba"
if (str == str[::-1]):
    print('Yes')
else:
    print('No')

#第三种做法
import operator
sStr = "acdhdca"
if operator.eq(sStr, ''.join(reversed(sStr))) == 1:    #使用operator.eq方法来判断是否相等
    print('Yes')
else:
    print('No')

str = "abcdcba"
print(type(reversed(str)))
print(type(''.join(reversed(str))))

输出结果如下所示：

Yes Yes Yes <class 'reversed'> <class 'str'>

其他字符串方法，在此就不展开讲述具体用法，代码如下：

s = "Blowing in the wind"
print(s.find("the"))              #find方法，用来查找字符串，加参数表示在此范围内查找
print(s.find("the", 1, 14))
print(s.lower())                  # lower方法，把字符串变成小写
print(s.split(' '))               # split方法，按照参数切割字符串，返回一个列表
print(s.replace("the", "that"))   # replace方法，替换字符串
alist = ["hello", "world"]
print(' '.join(alist))
y = '叶'
z = y.encode('utf-8')             # encode方法，对字符串编码
x = b'\xe6\x89\x8e\xe5\xbf\x83\xe4\xba\x86\xef\xbc\x8c\xe8\x80\x81\xe9\x93\x81'
print(z)
t = x.decode()                    # decode方法，对字符串解码
print(t)

运行结果如下所示：

11 11 blowing in the wind ['Blowing', 'in', 'the', 'wind'] Blowing in that wind hello world b'\xe5\x8f\xb6' 扎心了，老铁

转义字符：

\0	空字符	\t	横向制表符	\f	换页	\" \'	双(单）引号
\a	响铃	\n	换行	\r	回车	\\	反斜杠
\b	退格	\v	纵向制表符	\e	转义	\	续行符

用法同C语言类似，在此次不再赘述。

序号：

正向递增：从0开始
反向递减：从-1开始

使用：

索引：<字符串>[M]（取出第M个）
切片：<字符串>[M：N]（取出第M，M+1个，但不到第N个）
重复：a*10

具体代码如下所示：

aStr = "Hello,World"
bStr = aStr[:6]+'python!'
count = 0
for ch in bStr[:]:
    if ch in ',.!?':
        count += 1
print(count)        
print(bStr)         
   
# 输出结果如下所示
#2                  #程序中共有 2 个标点符号
#Hello,python!      #字符串被替换

2）列表

列表：list（有序，可变）

定义：

1.直接定义

li = [1,13,3-4j,"abcd"]

2.赋值定义

[a,b,c]=[100,12,13]

3.联合

a=[100,12,13]
b=[1,2,3]
c=a+b
print(c)

运行结果：

取值：

访问下标：

a=[100,12,13]
b=a[0]
print(b)

运行结果：

删除：

1.删除元素

a=[100,12,13]
del a[0]
print(a)

运行结果：

2.删除列表

a=[100,12,13]
del a
print(a)

运行结果：

添加：

1.在末尾添加

a=[100,12,13]
a.append(1)
print(a)

运行结果：

2.任意位置

a=[100,12,13]
a.insert(1,3)
print(a)

运行结果：

列表的一些方法，代码如下：

pScore = [9, 9, 8.5, 10, 7, 8, 8, 9, 8, 10]        #计算观众和评委的打分平均值
gScore = 9
pScore.sort()                  #pop方法，用于移除一个元素，默认最后一个
pScore.pop()
pScore.pop(0)
pScore.append(gScore)          #append方法，添加元素
aveScore = sum(pScore)/len(pScore)   #sum方法，求和
print(aveScore)                      #len方法，求长度

运行结果如下所示：

8.722222222222221

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
weekend = ['Saturday', 'Sunday']
week.extend(weekend)                #连接列表以及输出列表
for i, j in enumerate(week):
    #print(i+1, j)
    print(f'{i+1}: {j}')

运行结果如下所示：

1: Monday 2: Tuesday 3: Wednesday 4: Thursday 5: Friday 6: Saturday 7: Sunday

list1 = ['cc', 'a', 'r', 'bbbb']
list2 = [9, 2, 5, 4, 3]                   #排序
list1.sort(key=len)       #按长度排序
list2.sort(reverse=False)  #True,从大到小
print(list1)
print(list2)

运行结果如下所示：

['a', 'r', 'cc', 'bbbb'] [2, 3, 4, 5, 9]

列表解析：

一般是在需要改变列表，而不是需要新建某个列表的时候可以使用它，是由多个for循环以及可迭代的序列构成，代码如下所示：

a = [x for x in range(10)]
print(a)
b = [x ** 2 for x in range(10)]
print(b)
c = [x ** 2 for x in range(10) if x ** 2 < 50]
print(c)
d = [(x + 1, y + 1) for x in range(3) for y in range(3)]
print(d)
e = sum(x for x in range

运行结果如下所示：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] [0, 1, 4, 9, 16, 25, 36, 49] [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)] 10

一个用来清除非英文的小程序，代码如下：

def clean_list(lst):
    cleanded_list = []
    for item in lst:
        for c in item:
            if c.isalpha() != True:      # isalpha方法，判断是否是字母
                item = item.replace(c, '')   #替换
        cleanded_list.append(item)          #添加元素
    return cleanded_list

old_list = ['12edsdsde', 'yifasdadwe-0', 'dejawdd#', 'a!mdawcm%']
new_list = clean_list(old_list)
#print(new_list)
for k, v in zip(range(1, len(new_list)+1), new_list):
    print(k, v)

运行结果如下所示：

1 edsdsde 2 yifasdadwe 3 dejawdd 4 amdawcm

3）元组

元组：tuple（有序，不可变）

定义：

1.直接定义

tp = ('a','b','c')

2.赋值定义

(a,b,c)=(100,12,13)

3..联合

a=(100,12,13)
b=(2,)
c=a+b
print(c)

运行结果：

注：当元组里只有一个元素时，末尾要加，

取值：

访问下标：

a=(100,12,13)
b=a[0]
print(b)

运行结果：

删除：

只能删除整个元组

a=(100,12,13)
del a
print(a)

运行结果：

转换：

通过 set() 函数转换为集合

方法：

aTuple = (3, 5, 2, 4)
a = sorted(aTuple)    #元组没有sort函数，也说明它是不可变的  
print(a)              #sorted函数返回一个列表

运行结果如下所示：

[2, 3, 4, 5]

做可变长位置参数（元组）和返回值：

def fo(args1, *args):    #多个参数可以构成一个元组作为函数的参数
    print(args1)
    print(args)
fo('12edsdsde', 'yifasdadwe-0', 'dejawdd#', 'a!mdawcm%')

运行结果如下所示：

12edsdsde ('yifasdadwe-0', 'dejawdd#', 'a!mdawcm%') #多个参数当成元组

返回多个参数，代码如下：

def foo():
    return 1, 2, 3  #同其他语言有明显的区别
print(foo())        #返回值是一个元组

运行结果如下所示：

(1, 2, 3)

4）集合

集合：set【无序，不可重复（去重）】

分为可变集合（set）和不可变集合（frozenset）；不可变集合，顾名思义不能改变，和元组类似。

比较：

属于	in	不属于	not in	等于	==	不等于	！=
⊂	<	⊆	<=	⊃	>	⊇	>=

代码如下：

aSet = set('sunrise')
bSet = set('sunset')
print('u' in aSet)
print(aSet == bSet)
print(aSet < bSet)
print(set('sun') < aSet)

输出结果：

True False False True

运算：

交集：&
并集：|
差集：-（保留左侧独有的内容）

a={100,12,13}
b={100,12,1}
c=a-b
print(c)

运行结果：

余集:^（去掉相同元素）

a={100,12,13}
b={100,12,1}
c=a^b
print(c)

运行结果：

转换：

通过 list() 函数转换为列表

方法：

集合有较多的方法，在此举一部分例子，代码如下：

#所有集合都有的方法
aSet = set('sunrise')
bSet = set('sunset')
print(aSet.issubset(bSet))          #判断子集
print(aSet.intersection(bSet))      #取交集
print(aSet.difference(bSet))        #取差集
cSet = aSet.copy()                  #复制
print(cSet)
#可变集合才有的方法
aSet.add('!')                       #添加元素                   
print(aSet)                         
aSet.remove('!')                    #删除元素
print(aSet)
aSet.update('Yeah')                 #添加大量元素
print(aSet)
aSet.clear()                        #清除集合
print(aSet)

运行代码如下所示：

False {'u', 's', 'n', 'e'} {'r', 'i'} {'r', 's', 'i', 'u', 'n', 'e'} {'r', 'i', 'n', 'e', '!', 's', 'u'} {'r', 'i', 'n', 'e', 's', 'u'} {'r', 'i', 'n', 'e', 'h', 's', 'Y', 'u', 'a'} set()

5）字典

字典：dict

通过键值对存储数据(键具有唯一性）

定义：

1.直接定义，代码如下：

aInfo = {'Wangdachui': 3000, 'Niuyun':2000, 'Linling':4500, 'Tianqi':8000}
info = [('Wangdachui',3000), ('Niuyun',2000), ('Linling',4500), ('Tianqi',8000)]
bInfo = dict(info)
cInfo = dict([['Wangdachui',3000], ['Niuyun',2000], ['Linling',4500], ['Tianqi',8000]])
dInfo = dict(Wangdachui=3000, Niuyun=2000, Linling=4500, Tianqi=8000)
eInfo = dict((('Wangdachui',3000), ('Niuyun',2000), ('Linling',4500), ('Tianqi',8000)))
print(aInfo, type(aInfo))
print(bInfo, type(aInfo))
print(cInfo, type(aInfo))    #python支持多种方法定义字典
print(dInfo, type(aInfo))
print(eInfo, type(aInfo))

运行结果如下所示：

{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'> {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'> {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'> {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'> {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'>

2.一次给多个变量赋相同的值，代码如下：

aDict = {}.fromkeys(('Wangdachui','Niuyun', 'Linling', 'Tianqi'), 3000)
print(aDict)

运行结果如下所示：

{'Wangdachui': 3000, 'Niuyun': 3000, 'Linling': 3000, 'Tianqi': 3000}

3.通过zip函数将两个列表一一对应，变成字典，代码如下所示：

names = ['Wangdachui', 'Niuyun', 'Linling', 'Tianqi']
salaries = [3000, 2000, 4500, 8000]
aDict = dict(zip(names, salaries))
print(aDict)

运行结果如下所示：

{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000}

pList = [('AXP', 'American Express Company', '78.51'), ('BA', 'The Boeing Company', '184.76'),
         ('CAT', 'Caterpillar Inc.', '96.39'), ('CSCO', 'Cisco Systems,Inc.', '33.71'),
         ('CVX', 'Chevron Corporation', '106.09')]
aList = []
bList = []
for i in range(5):
    aStr = pList[i][0]
    bStr = pList[i][2]        #将一组数据的一部分拿出来形成字典
    aList.append(aStr)
    bList.append(bStr)
aDict = dict(zip(aList, bList))
print(aDict)

运行结果如下所示：

{'AXP': '78.51', 'BA': '184.76', 'CAT': '96.39', 'CSCO': '33.71', 'CVX': '106.09'}

取值：

1.通过键名

a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
b=a['a1']

2.通过get函数

a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
b=a.get("a1",1)
print(b)

运行结果：

123

注：若是字典a中包含键"a1"，则返回键"a1"的键值，若不包含键"a1"，则返回1,若是不设置第二个参数，则默认返回None

更改：

a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
a["a2"]=1
print(a)

运行结果：

{'a1': '123', 'a2': 1, 'b1': '345', 'b2': '456'}

添加:

a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
a["a3"]=1
print(a)

运行结果：

{'a1': '123', 'a2': '234', 'b1': '345', 'b2': '456', 'a3': 1}

删除：

1.删除元素

a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
del a["a1"]
print(a)

运行结果：

{'a2': '234', 'b1': '345', 'b2': '456'}

2.删除字典

a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
del a
print(a)

运行结果：

3.清除字典：

a = {"a1": "123", "a2": "234", "b1": "345", "b2": "456"}
a.clear()
print(a)

运行结果：

{}

主要内建函数，使用方法如下代码所示：

names = ['Wangdachui', 'Niuyun', 'Linling', 'Tianqi']
salaries = [3000, 2000, 4500, 8000]
aInfo = dict(zip(names, salaries))  #dict()用于创建字典
print(aInfo)
print(len(aInfo))                   #len()用于计算个数
print(hash('JXUST'))                #hash()用于判断是否可变（是否可哈希）

运行结果：

{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} 4 3915767897599782932

主要方法，使用方法如下代码所示：

1.输出键与值：

aInfo = {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000}
print(aInfo.keys(), type(aInfo.keys()))
print(aInfo.values())

运行结果：

dict_keys(['Wangdachui', 'Niuyun', 'Linling', 'Tianqi']) dict_values([3000, 2000, 4500, 8000])

2.输出键值一一对应：

aInfo = {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000}
for k, v in aInfo.items():
    print(k, v)

运行结果：

Wangdachui 3000 Niuyun 2000 Linling 4500 Tianqi 8000

3.更新字典:

aInfo = {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500}
print(aInfo)
bInfo = {'Wangdachui': 4000, 'Niuyun': 9999, 'Wangzi': 6000}
aInfo.update(bInfo)
print(aInfo)

运行结果：

{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500} {'Wangdachui': 4000, 'Niuyun': 9999, 'Linling': 4500, 'Wangzi': 6000}

字典的两种常见使用场景：

1.JSON格式

import json
x = {"name": "Niuyun", "address": {"city": "Beijing", "street": "Chaoyang Road"}}
json_str = json.dumps(x)     #编码
print(json_str)
print(x['address']['street'])
print(json.loads(json_str))  #解码

运行结果：

{"name": "Niuyun", "address": {"city": "Beijing", "street": "Chaoyang Road"}} Chaoyang Road {'name': 'Niuyun', 'address': {'city': 'Beijing', 'street': 'Chaoyang Road'}}

注：还可对JSON文件进行操作，在此不做展示

2.搜索引擎关键词查询

import requests
kw = {'q': 'Python dict'}
r = requests.get('http://cn.bing.com/search', params=kw)
print(r.text)

可变长关键字参数（字典）,代码如下：

def func(args1, *argst, **argsd):
    print(args1)
    print(argst)
    print(argsd)
func('Hello,', 'a', 'b', 'c', a1=1, a2=2, a3=3)

运行结果如下所示：

Hello, ('a', 'b', 'c') {'a1': 1, 'a2': 2, 'a3': 3}

注：要与元组的可变长位置参数区分开来

猜你喜欢

java小技能：对list集合根据条件进行分组、过滤和字段筛选
java小技能：JWT（json web token）认证实现
mybatis-plus小技能
Java小技能：快速创建List常用几种方式
数据库小技能：存储过程（stored procedure）
SQL SERVER 常用命令
代码要写到100岁--mysql之父monty见面会有感
docker快速拉起任意版本PostgreSQL测试环境
linux下内核信息追踪的几种工具
DBA的技术方向
gdb操作运行中的MySQL实例--"黑科技"
go vendor 迁移到go mod
redis cluster + predixy 手把手部署过程
hive beeline基本命令详解
微软官方PPT插件，海量优质模板免费用
看完这篇，还不会pandas时间数据处理，请你吃瓜
搞定了！Power Automate云端调用PAD
PAD 操控 pbi-tools 玩转 PBI 文件
PAD流程定时启动的三种方式
Hive 如何修改分区列？

当前栏目

（一）Python基本语法元素

程序的基本编写方法

输入

处理

输出

程序语法元素分析

程序的格式框架

命名与保留字

1） 变量

2） 命名

3) 保留字

数据类型

1）整形

2）浮点型

3）布尔型

4）复数类型（python特有的数据类型）

序列

访问模式

相关操作

1）字符串

类型说明符：

常用格式说明符：

字符串与输出形式：

字符串的应用：

转义字符：

序号：

使用：

2）列表

定义：

取值：

删除：

添加：

列表解析：

3）元组

定义：

取值：

删除：

转换：

做可变长位置参数（元组）和返回值：

4）集合

比较：

运算：

转换：

方法：

5）字典

定义：

取值：

添加:

删除：

字典的两种常见使用场景：

相关文章

1）变量

2）命名