python3字典运算_python基础：python循环、三元运算、字典、文件操作

目录：

python循环

三元运算

字符串

字典

文件操作基础

一、python编程

在面向过程式编程语言的执行流程中包含：

顺序执行

选择执行

循环执行

if是条件判断语句；if的执行流程属于选择执行；if语句有三种格式，如下：

在多分支的if表达式中，即使多个条件同时为真，也只会执行一个，首先测试为真；

选择执行

单分支的if语句

if CONDITION:

条件为真分支

双分支的if语句

if CONDITION

条件为真分支

else

条件不满足时分支

多分支的if语句

if CONDITION1

条件1为真分支

elif CONDITION2

条件2为真分支

elif CONDITION3

条件3为真分支

...

elif CONDITIONn

条件n为真分支

else

所有条件均不满足时的分支

示例：

age = 56guess_num= int(input('your guess num:'))if guess_num == 56:print('Congratulations, you got it')elif guess_num >age:print('try smaller...')else:print('try bigger...')

循环执行

for循环：

for循环是遍历文件中的每个元素来实现循环；元素遍历完成即退出循环；

示例：

>>> for i in range(10):

print(i)

...

01

2

3

4

5

6

7

8

9

while循环：

是计算机编程语言中的一种控制流程语句。主要由一个代码块(作为循环体)和一个表达式(作为循环条件)组成，表达式为布尔(boolean)型。循环体内的代码执行一次后，程序会去判断这个表达式的返回值，如果这个表达式的返回值为“true”(即满足循环条件)时，则循环体内的代码会反复执行，直到表达式的返回值为“false”(即不满足循环条件)时终止。程序会在每次循环体每执行一次后，进行一次表达式的判断。

示例：

count =0whileTrue:print(count)if count > 9:breakcount+=101

2

3

4

5

6

7

8

9

10

循环进入与退出的条件：

for循环

进入条件：列表元素非空

退出条件：列表元素遍历完成

while循环

进入条件：条件测试结果为真

退出条件：条件测试结果为假

循环控制语句：

continue:  跳出本轮循环，进入下一轮循环；

break: 跳出当前层整个循环；

示例：

for i in range(10):if i == 5: #表示如果循环时i等于5，如果是continue则直接跳过本轮循环，不进行打印

continue

print(i)

01

2

3

4

6

7

8

9

for i in range(10):if i == 5:for j in range(10,20):if j == 16:break #循环时j等于16，使用break则跳出本层循环，而不会跳出整个循环；

print(j)print(i)

01

2

3

4

10

11

12

13

14

15

5

6

7

8

9

注：在python中pass表示占位符的意思；

2.　　三元运算：

三目运算符，计算机c语言的重要组成部分。条件运算符是唯一有3个操作数的运算符，所以有时又称为三元运算符。

?:; "?"运算符的含义是: 先求表达式1的值, 如果为真, 则执行表达式2，并返回表达式2的结果 ; 如果表达式1的值为假, 则执行表达式3 ，并返回表达式3的结果。

示例：

a = 10b= 15c= a+b if a

3.  元组

元组只有index与count两个方法；元组是不可变的；又名只读列表；

示例：

tup=('mac','jack','bike','bike','iphone')print(tup.count('bike'))print(tup.count('jack'))print(tup.index('iphone'))2

1

4

4. 字符串

字符串是不可改变的；python中一个字符串或一个列表或列表中一个元素就是一个对象；在python中所有方法都是通过.来进入调用的；

示例：

>>> name = 'hsggj'

>>> name.index('s') #查找索引位置

1

>>> name.capitalize() #首字母成大写

'Hsggj'

>>> name='Hsggj Guo'

>>> name.casefold() #大写全部替换成小写

'hsggj guo'

>>> name.count('g') #统计字数

2

>>> name.find('Gu') #查找的意思，找到则返回位置，找不到则返回-1

6

>>> name.endswith('uo') #是否以uo结束，如果是则打印True,否则打印False

True>>> name='hsggj\tguo'

>>> name.expandtabs(20) #expandtabs是替换\t的空格数，20表示20个空格

'hsggj guo'字符替换的两种方法：>>> msg='my name is {0}, and i am {1} years old'

>>> msg.format('hsggj',22)'my name is hsggj, and i am 22 years old'

>>> msg1='my name is {name}, and i am {age} years old'

>>> msg1.format(age=22,name='hsggj')'my name is hsggj, and i am 22 years old'

>>> name='hsggj'

>>> name1='My Name Is Hsggj'

>>> d='123'

>>> 'ad'.isalpha() #表示是否为字符串

True>>> name.isalpha() #表示是否为字符串

True>>> 'a2d'.isalnum() #是否为字符串和数字

True>>> name.isalnum() #是否为字符串和数字

True>>> d.isdigit() #是否为数字

True>>> name.isidentifier() #变量名是否合法

True>>> name.isupper() #是否全大写

False>>> name.islower() #是否全小写

True>>> d.isdecimal() #是否包含十进制数字

True>>> d.isnumeric() #是否只包含数字，包括十进制数字和其它特殊数字

True>>> name.isprintable() #是否可打印

True>>> name1.istitle() #是否为一个title

True>>> l1=['mac','jack','bike']>>> ','.join(l1) #将列表替换成字符串

'mac,jack,bike'

>>> name.ljust(20,'-') #左对齐字符串，最右边填充‘-’

'hsggj---------------'

>>> name.rjust(20,'-') #右对齐字符串，最左边填充‘-’

'---------------hsggj'

>>> name.center(20,'-') #字符串居中，两边填充‘-’

'-------hsggj--------'

>>> name2='hsggj \n'

>>> name2.strip() #字符串两边去除空白

'hsggj'

>>> name2.lstrip() #字符串左边去除空白

'hsggj \n'

>>> name2.rstrip() #字符串右边去除空白

'hsggj'

>>> name = 'hsggj guo'

>>> name.replace('gg','DDDDD') #对字符串进行匹配并替换

'hsDDDDDj guo'

>>> name.split('s') #将字符串替换成列表，以s分割

['h', 'ggj guo']>>> name.zfill(20) #返回一个长度为20的字符串，最左边填充0

'00000000000hsggj guo'

字符串的简单加密：

from_str = "!@#$%^"to_str= "hjklmn"trans_table=str.maketrans(to_str,from_str)print("hsggj".translate(trans_table))

!sgg@

5. 字典

>>> d1 ={

...'stu1':'hsggj',

...'stu2':'jack',

...'stu3':'mac'... }>>> d1.get('stu1','sss') #如果有值则返回，无值则返回sss

'hsggj'

>>> d1.keys() #返回所有的key

dict_keys(['stu1', 'stu3', 'stu2'])>>> d1.items() #返回所有的键值

dict_items([('stu1', 'hsggj'), ('stu3', 'mac'), ('stu2', 'jack')])>>> d1.values() #返回所有的值

dict_values(['hsggj', 'mac', 'jack'])>>> d1.pop('stu2') #删除stu2

'jack'

>>>print(d1.setdefault('stu6','wss')) #如果有则返回，没有则返回wss

wss#字典的增加

>>> d1['stu4'] = ['tom',25,'cat']>>> print(d1)

{'stu1': 'hsggj', 'stu4': ['tom', 25, 'cat'], 'stu3': 'mac', 'stu2': 'jack'}#字典的修改

>>> d1['stu4'][0] = 'TOM'

>>> print(d1)

{'stu1': 'hsggj', 'stu4': ['TOM', 25, 'cat'], 'stu3': 'mac', 'stu2': 'jack'}#字典的删除

>>> print(d1.pop('stu5','sss'))

sss>>> print(d1.pop('stu2','sss'))

jack>>> print(d1)

{'stu1': 'hsggj', 'stu4': ['TOM', 25, 'cat'], 'stu3': 'mac'}>>>print(d1.popitem()) #随机删除

('stu1', 'hsggj')#字典中值的替换

>>> print(dict.fromkeys(d1,1))

{'stu1': 1, 'stu4': 1, 'stu3': 1}>>> print(dict.fromkeys(d1,'hsggj'))

{'stu1': 'hsggj', 'stu4': 'hsggj', 'stu3': 'hsggj'}#字典的合并

>>>d2 = {'stu6':'TOM',1:333,3:888}

d1.update(d2)print(d1)>>>{1: 333, 3: 888, 'stu3': 'mac', 'stu1': 'hsggj', 'stu6': 'TOM', 'stu2': 'jack'}#字典中的浅复制

(浅复制只能复制第一层，不能复制第二层，第二层的id是不一样的，但第二层的id是一样的；>>>n3 = dict.fromkeys(d1,1)

n3['stu1'] = 2

print(n3)>>>{'stu3': 1, 'stu2': 1, 'stu1': 2} 1659162384 1659162352

>>>n3 = dict.fromkeys(d1,[1,2,3])

n3['stu2'][2] = 9

print(n3)>>>{'stu3': [1, 2, 9], 'stu2': [1, 2, 9], 'stu1': [1, 2, 9]} 2620113945224 2620113945224

6. 字典的循环

d1 ={'stu1':'hsggj','stu2':'jack','stu3':'mac'}for key ind1:print(key,d1[key])

stu2 jack

stu1 hsggj

stu3 macfor k,v ind1.items():print(k,v)

stu2 jack

stu1 hsggj

stu3 mac

注：第一种效率要比第二种高，第二种在执行循环的时候要先把字典转换成元组后再进行遍历，文件按G来算其实效率光转换就很慢了

7. 浅复制与深复制

importcopy

d1= {'name':'tom','acc':{'id':3333,'blance':1000}}

d2=d1.copy()

d3=copy.deepcopy(d1)

d3['name'] = 'jerry'

print(d1,d2,d3)

{'name': 'tom', 'acc': {'blance': 1000, 'id': 3333}} {'name': 'tom', 'acc': {'blance': 1000, 'id': 3333}} {'name': 'jerry', 'acc': {'blance': 1000, 'id': 3333}}

d2['name'] = 'jack'

print(d1,d2,d3)

{'name': 'tom', 'acc': {'blance': 1000, 'id': 3333}} {'name': 'jack', 'acc': {'blance': 1000, 'id': 3333}} {'name': 'jerry', 'acc': {'blance': 1000, 'id': 3333}}

d1['acc']['blance']-=300

print(d1,d2,d3)

{'name': 'tom', 'acc': {'blance': 700, 'id': 3333}} {'name': 'jack', 'acc': {'blance': 700, 'id': 3333}} {'name': 'jerry', 'acc': {'blance': 1000, 'id': 3333}}

d3['acc']['blance']-=100

print(d1,d2,d3)

{'name': 'tom', 'acc': {'blance': 700, 'id': 3333}} {'name': 'jack', 'acc': {'blance': 700, 'id': 3333}} {'name': 'jerry', 'acc': {'blance': 900, 'id': 3333}}

d2['acc']['blance']-=500

print(d1,d2,d3)

{'name': 'tom', 'acc': {'blance': 200, 'id': 3333}} {'name': 'jack', 'acc': {'blance': 200, 'id': 3333}} {'name': 'jerry', 'acc': {'blance': 900, 'id': 3333}}#d1与d2随着对方的blance减少而减少，而d3则减少一次就再也没有变化过，这就是深复制与浅复制

7. 文件操作

f = open('a.txt')

关于open 模式：

w 以写方式打开，

a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)

r+以读写模式打开

w+以读写模式打开 (参见 w )

a+以读写模式打开 (参见 a )

rb 以二进制读模式打开

wb 以二进制写模式打开 (参见 w )

ab 以二进制追加模式打开 (参见 a )

rb+ 以二进制读写模式打开 (参见 r+)

wb+ 以二进制读写模式打开 (参见 w+)

ab+ 以二进制读写模式打开 (参见 a+)

f.replace(old,new)#内容替换

f.close() #关闭文件并保存

f.flush() #缓存刷写到硬盘上

f.read() #读取文件所有行

f.readline() #读取文件一行

f.readlines() #读取文件所有内容，包含特殊字符

f.write(str) #把str写入到文件中