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

目录：

  • python循环
  • 三元运算
  • 字符串
  • 字典
  • 文件操作基础

一、python编程

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

　　　　顺序执行

　　　　选择执行

　　　　循环执行

  1. 　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 = 56
guess_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)
...
0
1
2
3
4
5
6
7
8
9

　　　while循环：

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

　　  示例：

　　　　　　

count = 0
while True:
    print(count)
    if count > 9:
        break
    count+=1

0
1
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)

0
1
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)

0
1
2
3
4
10
11
12
13
14
15
5
6
7
8
9

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

　　2.　　三元运算：

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

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

　　示例：

a = 10
b = 15
c = a+b if a<b else a-b
print(c)

25

　　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 = "[email protected]#$%^"
to_str = "hjklmn"
trans_table = str.maketrans(to_str,from_str)
print("hsggj".translate(trans_table))

[email protected]

　　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 in d1:
    print(key,d1[key])

stu2 jack
stu1 hsggj
stu3 mac

for k,v in d1.items():
    print(k,v)

stu2 jack
stu1 hsggj
stu3 mac

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

　　　7. 浅复制与深复制

　　　　

import copy

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写入到文件中

　　

　　

　　

时间： 2024-10-06 20:20:42

python基础：python循环、三元运算、字典、文件操作的相关文章

python基础-第四篇-4.2文件操作

基本打开模式 文件操作的流程:打开文件,操作文件,关闭文件 打开文件方法:open(文件名,模式,编码) file = open(‘文件名’) 模式在不给值的情况下,默认为只读,而且如果是非当前的目录下文件名要加绝对路径 ‘r’--只读 file_name.read()   一次性把指针后的内容全部读出来 file_name.readlines()  把指针后内容,以列表的形式每行读出 f = open('ha.log','r') data1 = f.readlines() f.close()

三元运算、文件操作

三元运算: 三元运算又称三目运算,是对简单的条件语句的简写.如: 简单条件语句: if 条件成立: val = 1 else: val = 2 变成三元运算是: val = 1 if 条件成立 else 2 文件操作: 文件操作包括读.写.修改. 读: f = open( file = ' F: /工作日常/文件名.txt' , mode = 'r', encoding = 'utf-8')   # 'r' 表示以(文本)读的模式打开文件(只能把文本转化成字符串), encoding= 的作用是

函数式编程(三元运算、文件操作)

一.三元运算 简介: 三元运算又称三目运算,是对简单的条件语句简写,如: #简单条件语句 if 1 < 2: var =1 else: var = 2 print(var) #改成三元运算 var_1 = 1 if 1 < 2 else 2 print(var_1) #输出 1 1 二.文件处理 文件操作分为读.写.修改. 读: #注意这个路径如果不写绝对路径就是与python程序处于同一路径,建议使用绝对路径 #这里一定要注意编码的问题,以什么编码写的要以什么编码打开,否则就是乱码了 #mo

Python基础教程系列：九、文件操作

一.open()函数 open()以及file()(open()与file()等价,可以任意替换)提供了初始化输入/输出(I/O)操作的通用接口.open()函数成功打开一个文件后就会返回一个文件对象,说白了你就可以接着读写了,否则就bug了. 语法:file_object = open(file_name, access_mode='r', buffering=-1) 第一个参数是文件名或者路径(绝对或相对路径),第二个参数叫文件打开的模式,不写时默认是'r'模式.'r'模式是只读模式.'w'

Python基础06 循环

Python基础06 循环 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 循环用于重复执行一些程序块.从上一讲的选择结构,我们已经看到了如何用缩进来表示程序块的隶属关系.循环也会用到类似的写法. for循环 for循环需要预先设定好循环的次数(n),然后执行隶属于for的语句n次. 基本构造是 for 元素 in 序列: statement 举例来说,我们编辑一个叫forDemo.py的文件 for a in [3,4.4,

第三章、三元运算、文件处理、函数

第三章.三元运算.文件处理.函数 三元运算 三元运算又称三目运算,是对简单的条件语句的简写,如: 简单条件语句: if 条件成立: val = 1 else: val = 2 # 可以写成如下: val = 1 if 条件成立 else 2 文件处理 读,写,修改 读 f = open(file='d:/*.txt', mode='r', encoding='utf-8') date = f.read() f.close() r是只读模式,rb是以二进制读文件 第三方模块 chardet检测二进

Python基础-Python流程控制

上篇文章 Python基础-基础使用 我们已经知道了Python解释器,Python的变量.和Python的输入输出.Python的注释和字符集,这篇文章,我们主要讲Python的流程控制 本文防盗链:http://python789.blog.51cto.com Python基础-Python流程控制 1.条件判断 1.1.if基本使用 if就是一个条件判断的,当满足不同样的条件的时候执行不同的操作,如法如下: if 条件1:     满足条件1 代码框 elif 添加2:     满足条件2

php基础知识总结（2）文件操作file

一.路径 1.dirname -- 返回路径中的目录部分      $path = "/etc/passwd";      $file = dirname($path); // "/etc" 2.basename -- 返回路径中的文件名部分     $path = "/home/httpd/html/index.php";     $file = basename($path);        // index.php     $file =

Python初学者第十四天 三元运算及文件处理2

14day 1.三元运算: 又称三目运算,是对简单的条件语句的简写 如简单条件语句: if a > b: n = a else: n = b print(n) 三目运算语句: n = a if a > b else b print(n) 2.文件处理 2.1 文件处理:读 当不知道文本以何种编码格式储存时,可以使用"b",以二进制的方式打开,用以网络传输 原文地址:https://www.cnblogs.com/fany-mok/p/8290355.html

Python自动化 【第二篇】：Python基础-列表、元组、字典

本节内容 模块初识 .pyc简介 数据类型初识 数据运算 列表.元组操作 字符串操作 字典操作 集合操作 字符编码与转码 一.模块初识 Python的强大之处在于他有非常丰富和强大的标准库和第三方库,几乎你想实现的任何功能都有相应的Python库支持,让我们先来象征性的学2个简单的. sys 1 #!/usr/bin/env python 2 3 # -*- coding: utf-8 -*- 4 5 6 7 import sys 8 9 10 11 print(sys.argv) 12 13