python笔记——Python语法

just kind man

已于 2024-07-18 14:36:31 修改

阅读量317

点赞数 3

分类专栏： Python 文章标签： python 笔记开发语言

于 2024-07-18 14:30:23 首次发布

本文链接：https://blog.csdn.net/m0_74048879/article/details/140522392

版权

Python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Python语法

输入

表达式解析

变量 = eval(input("提示字符串"))

通过一个内置的函数eval()，将用户输入的字符串解析为表达式(单个数据也是表达式),若表达式可计算，则计算后返回其值。
可认为eval是去掉接收到的字符串的引号。

输出

1.普通输出

print(<表达式1>[,<表达式2>,…,<表达式n>, sep='', end='\n'])

参数说明：

sep：输出表达式之间的间隔字符串，默认是空格
end：输出表达式的结尾字符串，默认是换行

a = eval(input())  		   #输入：3
print("a", "=", a) 		   #输出： a = 3
print("a", "=", a, sep='') #输出：a=3

2.格式化字符串输出(格式字符串和输出表达式之间用%隔开)

print(“格式字符” % 表达式)

格式字符	含义
%s	字符串格式
%d	整数格式
%c	字符格式
%f	浮点数格式
%o	八进制格式
%x或%X	十六进制格式
%e或%E	科学计数法格式

字符	作用
m	定义输出宽度，若宽度超过m，则全部输出
-	在指定宽度内输出内容左对齐
+	输出正数时在前面加’+'号
#	输出八进制时前面加0o，输出十六进制时加ox或oX
0	在指定宽度内输出时，左边的空位以0填充
.n	对于浮点数，此字符表示保留的小数位数(四舍五入)，对于字符串，则表示仅输出串的前n位

#整数示例
x=1024
print("x=%6d" % x)		#x=  1024
print("x=%2d" % x)		#x=1024
print("x=%-6dEND" % x)  #x=1024  END
print("x=%+6d" % x)		#x= +1024
print("x=%06d" % x)		#x=001024
print("x=%#o" % x)		#x=0o2000
print("x=%#x" % x)		#x=0x400

#浮点数示例
x=128.3656
print("x=%8.2f" % x)	#x=  128.37
print("x=%.2e" % x)		#x=1.28e+02

#字符串示例
name = '湖南科技大学'
print("%-10.2sEND" % name)	#湖南        END

3.格式化函数输出

基本用法

name = input()
age = int(input)
print("姓名：{},年龄{}".format(name,age))
print("姓名：{1},年龄{0}".format(age,name))
print("姓名：{n},年龄{a}".format(n=name,a=age))
#姓名：张三,年龄18

进阶用法

‘<’ 左对齐
‘>’ 右对齐
‘^’ 中间对齐
“{:4s}” 输出四位

r = 3
pi = 3.1415926
area = pi*r*r
print("{:.2f}".format(pi))
print("半径：{0:<3d},面积：{1:10.3f}".format(r,area))
#3.14
#半径：3  ，面积：    28.274

4.f-string 简化输出

r=3
pi=3.1415926
area=pi*r*r
print(f"半径：{r:<3d},面积：{area:10.3f}")

数据类型

Number(数字)：int、float、bool、complex(复数)
String(字符串)
List(列表)
Tuple(元组)
Set(集合)
Dictionary(字典)
不可变数据类型：number、str、tuple
可变数据类型：list、dictionary、set

整型

没有长度限制
支持四种进制：十、二(0b或0B)、八(0o或0O)、十六(0x或0X)

浮点型

科学计数法：-27.3e2
只有十进制浮点数
有长度限制、

复数型

使用1j或1J表示-1的平方根
real(实部)和imag(虚部)

布尔型

True和False(首字母大写)
运算时True的值为1，False的值为0

运算符

运算符	描述	实例	结果	备注
+	加	3+4.5	7.5
-	减	12-4.8	7.2
*	乘	2*5.0	10.0
/	除	10/4	2.5
//	整数除法	10//4	2	向下取整
%	取余	10%3	1	余数符号与除数相同 -2.5%2.25=2.0
**	乘方	2**3	8	4.0**0.5=2.0

内置数值函数

函数	描述
abs(x)	x的绝对值
divmod(x,y)	输出(x//y, x%y)
pow(x,y[,z])	x的y次方在对z取模 pow(x,y) %z
round(x[,ndigits])	对x四舍五入，保留ndigits位小数
max(x,y,z,……)	返回最大值
min(x,y,z,……)	返回最小值
log(x[,base])	返回x的以base为底的对数，base默认为e

字符串

0	1	2	3
人	生	苦	短
-4	-3	-2	-1

s[n : m : step]表示字符串s中索引从n到m的子字符串

若n缺省，表示从头开始
若m缺省，表示取到最后一个字符
若m和n缺省，取整个字符串
step>0时从左向右取字符，<0时从右向左取字符
每次取字符的间隔是|step|-1

字符串运算

字符串运算符	描述
+	“AB”+“123”=“AB123”
*	“Tom”*3=“TomTomTom”
in	“He” in “Hello” = True

字符串处理函数	描述
len(x)	x的长度
str(x)	将任意类型x转换成字符串类型
chr(x)	返回Unicode编码为x的字符
ord(x)	返回字符x的Unicode编码
hex(x)	将整数x转换为十六进制数，并返回其小写字符串形式
oct(x)	将整数x转换为八进制数，并返回其小写字符串形式

字符串查找类方法	描述
find()和rfind()	分别用来查找一个字符串在另一个字符串指定范围中首次和最后一次出现的位置，如果不存在则返回-1
index()和rindex()	分别用来查找一个字符串在另一个字符串指定返回中首次和最后一次出现的位置，若不存在则抛出异常
count()	返回一个字符串在另一个字符串中出现的次数，如歌不存在则返回0

字符串方法	描述
split()和rsplit()	分别从字符串左端和右端开始将其分割成多个字符串，并返回含分割结果的列表
partition()和rpartition()
join()	将列表中多个字符串进行连接，并在相邻两个字符串之间插入指定字符，返回新字符串
lower()和upper()	分别全部转换为小写和大写
capitalize()	首字母大写
title()	每个单词首字母大写
swapcase()	全部大小写转换
replace(x,y)	用y替换指定字符串中的字符串x
strip()	删除两端空白字符
rstrip()	删除右端空白字符
lstrip()	删除左端空白字符
strip(‘=’)	删除两端指定字符’=’
startswith(‘=’)	检测字符串是否以’='开始
endswith(‘=’)	检测字符串是否以’='结束
isupper()	判断是否全大写
islower()	判断是否全小写
isdigit()	判断是否全数字
isalpha()	判断是否全字母
isalnum()	判断是否数字字母串
center(x,'=)	串居中，输出宽度x,不足的补 ‘=’
ljust(x,'=)	串居左，输出宽度x,不足的补 ‘=’
rjust(x,‘=’)	串居右，输出宽度x,不足的补 ‘=’
zfill(x)	串居右，输出宽度x,不足的补 ‘0’

分支结构

if

if 条件表达式1:
    语句块1
elif 条件表达式2:
    语句块2
else:
    语句块3

简洁表达式

表达式1 if 条件表达式 else 表达式2

for

for 变量 in 可迭代对象:
    语句块

for 变量 in 迭代器:
    语句块1
else:
    语句块2
#for循环正常结束(迭代器为空)时，else下的语句块2会执行
#for循环非正常结束(没迭代完被中断了),不会执行else

range(start,stop[,step])

参数说明：

start：计数从start开始，默认值为0
stop：计数到stop结束，但不包括stop，不能缺省
step：步长，默认为1

sum = 0
for i in range(1,101):
    sum +=i
print("1~100的总和：{:6d}".format(sum))

while

while 条件表达式:
    语句块

break和continue

break：中断整个循环
continue：中断本次循环

列表

列表元素类型可以互不相同

修改元素

scores = [98,86,95,74]
scores[3] = 80
students = [['张三', 19, '湘潭'], ['李四', 18, '南京']]
students[1][2] = "常州"
students[1] = ['王五',20,'武汉']

添加元素

#列表.append(y)   在末尾加上元素y
scores = [ 98,86,95,74,82]
scores.append(77)		#scores = [98, 86, 95, 74, 82, 77]

#列表insert(x,y)  在索引为x之前插入元素y
scores = [ 98,86,95,74,82]
scores.insert(-1, 77)		#scores =[98, 86, 95, 74, 77, 82]

删除元素

#del 列表[索引]
scores = [ 98,86,95,74,82]
del scores[1]		#scores = [ 98,95,74,82]

#列表.pop([索引])
scores = [98,86,95,74,82]
scores.pop() # 默认删除最后一个元素
s = scores.pop(2) # pop函数会返回被删除的元素
#[98, 86, 95, 74]
#[98, 86, 74]

#列表.remove(x)
scores = [98,82,95,74,82]
scores.remove(82) # 删除第一次出现的82，返回值为None

常用操作

其他常用操作	描述
len(列表)	返回列表中元素个数
元素 in (not in) 列表	判断元素是否在列表中
列表. index(x)	列表中查找指定元素，如果找到返回第一个索引，未找到则报错
列表.count(x)	对列表值为x的元素进行计数

遍历

lst = [1,2,3,4,5,2,3]
for i in lst:
 print( i, end="," )
#1,2,3,4,5,2,3,

#使用range
lst = [1,2,3,4,5,2,3]
for i in range(len(lst)):
 print(lst[i], end = "," if i < len(lst)-1 else " " )
#1,2,3,4,5,2,3

元素排序

#list.sort(key=None,reverse=False)
lst = [1,2,3,4,5,2,3]
print(lst.sort()) # 返回值是None
print("升序：",lst) # lst调用sort后，已经被原地排序
lst.sort(reverse=True) # 设置reverse参数，可非升序排
print("降序：",lst)
#None
#升序： [1, 2, 2, 3, 3, 4, 5]
#降序： [5, 4, 3, 3, 2, 2, 1]

#sorted(待排序对象,key=None,reverse=False)
ls = [3,2,6,4,5,1]
sorted(ls) # ls不变
print(ls)
ls = sorted(ls) # 返回排序列表，重新赋值给ls
print(ls)
#[3, 2, 6, 4, 5, 1]
#[1, 2, 3, 4, 5, 6]

注：元素类型可比，才能进行排序

切片

#列表 [ 起始索引 （包含）：终止索引（不包含） ：步长 ]
ls = [1,2,3,4,5,6]
print(ls[1:3])
print(ls[:]) # 或ls[::]
print(ls[::-1])
#[2, 3]
#[1, 2, 3, 4, 5, 6]
#[6, 5, 4, 3, 2, 1]

扩充

#列表1 + 列表2
lst1 = [1,2,3,4,5,6]
lst2 = [7,8,9]
print(lst1 + lst2)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]

#列表1.extend(列表2)
lst1 = [1,2,3,4,5,6]
lst2 = [7,8,9]
lst1.extend(lst2)
print(lst1)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]

#列表 * 重复次数
lst1 = [1,2,3,4,5,6]
print(lst1*2)
#[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

复制

切片list[:]：深拷贝（两份空间）
使用列表的copy方法：深拷贝
通过列表之间的赋值操作：浅拷贝（共享空间）

#1
lst1 = [1,2,3,4,5,6]
lst2 = lst1[:]
lst2[0] = 9
print(lst1)
print(lst2)
#[1, 2, 3, 4, 5, 6]
#[9, 2, 3, 4, 5, 6]

#2
lst1 = [1,2,3,4,5,6]
lst2 = lst1.copy()
lst2[0] = 9
print(lst1)
print(lst2)
#[1, 2, 3, 4, 5, 6]
#[9, 2, 3, 4, 5, 6]

#3
lst1 = [1,2,3,4,5,6]
lst2 = lst1
lst2[0] = 9
print(lst1)
print(lst2)
#[9, 2, 3, 4, 5, 6]
#[9, 2, 3, 4, 5, 6]

删除

#清空
lst1 = [1,2,3,4,5,6]
del lst1[:]
#del后直接跟列表名，则将彻底删除该列表对象！
lst1 = [1,2,3,4,5,6]
del lst1

生成

#输入生成
lst1 = eval(input("输入列表1："))
print("lst1=",lst1)
lst2 = list(eval(input("输入列表2：")))
print("lst2=",lst2)
#输入列表1：[1,2,3,4,5]
#lst1= [1, 2, 3, 4, 5]
#输入列表2：1,2,3,4,5
#lst2= [1, 2, 3, 4, 5]

#遍历生成
lst1 = [] # 创建空列表
for i in range(6):
 lst1.append(input())
print("lst1=",lst1)
#输入：
#1
#a
#3.14
#0
#189
#hello
#输出：
#lst1= ['1', 'a', '3.14', '0', '189', 'hello']

#函数转换
lst1 = list(range(6))
print(lst1)
lst2 = list(range(1,10,3))
print(lst2)
lst3 = list('hello')
print(lst3)
#[0, 1, 2, 3, 4, 5]
#[1, 4, 7]
#['h', 'e', 'l', 'l', 'o']

#输入、切分、映射、转换链式调用获得整数列表
lst1 = list(map(int, input().split()))
print("lst1=", lst1)
#1 2 3 4 5
#lst1= [1, 2, 3, 4, 5]

元组

元组使用圆括号()
元组的元素不能修改
列表中不涉及元素修改的操作都适用于元组

在这里插入图片描述

字典

字典属于Python中一种基本的数据结构——映射。它通过键值对的方式存储了数据与数据之间的对应关系。

{ 键1 : 值1, 键2 : 值2, …… }

键具有唯一性，字典中不允许出现相同的键，但是不同的键允许对应相同的值
字典中的键必须是不可变的类型，一般是字符串、数字或者元组；而值可以是任何数据类型。

创建

用大括号直接创建字典
dict方法，传入双元素序列创建字典

d = {} 
d2 = dict() 
dicAreas = {'俄罗斯 : 1707.5, '加拿大' : 997.1, '中国' : 960.1 } 
countryAreas = ( ('俄罗斯',1707.5), ('加拿大',997.1), ('中国',960.1) )
dicAreas=dict(countryAreas)
countryList=[('俄罗斯',1707.5),('加拿大',997.1),('中国',960.1)]
dicAreas=dict(countryList)

访问

字典是无序的，不能通过序号、只能通过键访问其对应的值。
字典只提供“键”到“值”的单向访问，不能通过“值”直接反向访问“键”。
使用不存在的键访问字典条目会引起系统报错。

添加与修改

dicAreas={'俄罗斯':1707.5, '加拿大':997.1, '中国':960.1}
dicAreas['美国'] = 997.1 # 无此键，添加条目
print(dicAreas)
dicAreas['美国'] = 937.3 # 有此键，修改条目
print(dicAreas)
#{'俄罗斯': 1707.5, '加拿大': 997.1, '中国': 960.1, '美国': 997.1}
#{'俄罗斯': 1707.5, '加拿大': 997.1, '中国': 960.1, '美国': 937.3}

删除

1.用del命令删除指定条目，键不存在时报错。

dicAreas ={'俄罗斯':1707.5, '加拿大':991.7, '中国':960.1}
del dicAreas['加拿大']
print(dicAreas)
#{'俄罗斯': 1707.5, '中国': 960.1}

2.用 pop(键) 方法删除指定条目，删除同时返回被删除条目的值键不存在则报错，若不想系统报错，可采用pop(键, 默认值)法。

dicAreas ={'俄罗斯':1707.5, '加拿大':991.7, '中国':960.1}
print(dicAreas.pop('中国')) # 返回该键对应的值
print(dicAreas) # 原字典被原地pop
print(dicAreas.pop('美国')) # 不存在该键，报错
print(dicAreas.pop('美国', '条目不存在'))
#960.1
#{'俄罗斯': 1707.5, '加拿大': 991.7}
#条目不存在

3.用popitem方法删除并返回最后一个字典条目：

#字典名.popitem()
dicAreas={'俄罗斯':1707.5, '加拿大':997.1, '中国':960.1}
print(dicAreas.popitem())
print(dicAreas)
#('中国', 960.1)
#{'俄罗斯': 1707.5, '加拿大': 997.1}

4.用clear方法清空字典条目

#字典名.clear()
dicAreas={ '俄罗斯' :1707.5, '加拿大' :997.1, '中国' :960.1}
dicAreas.clear()
print(dicAreas)
#{}

5.用del命令删除整个字典

#del 字典名
dicAreas={ '俄罗斯' :1707.5, '加拿大' :997.1, '中国' :960.1}
del dicAreas

判断键存在

1.成员运算in

#键 in 字典
dicAreas={ '俄罗斯' :1707.5, '加拿大' :997.1, '中国' :960.1}
print('中国' in dicAreas) 
print('美国' in dicAreas)
#True
#False

2.get方法

get方法按照指定的“键”访问字典中对应条目，并返回其对应的“值”；
如果指定的键不存在时，若没有设置default，则报错，否则返回default。

#get(key,default=None)
dicAreas={ '俄罗斯' :1707.5, '加拿大' :997.1, '中国' :960.1}
print(dicAreas['俄罗斯']) # 1707.5
print(dicAreas['巴西']) # KeyError: '巴西'
print(dicAreas.get('巴西', '未知')) # 未知

遍历

items()：提取字典所有条目,以双元素列表形式返回、
keys()：提取字典所有键,以列表形式返回
values()：提取字典所有值,以列表形式返回

dicAreas={ '俄罗斯' :1707.5, '加拿大' :997.1, '中国' :960.1}
print(dicAreas.items())
print(dicAreas.keys())
print(dicAreas.values())
#dict_items([('俄罗斯', 1707.5), ('加拿大', 997.1), ('中国', 960.1)])
#dict_keys(['俄罗斯', '加拿大', '中国'])
#dict_values([1707.5, 997.1, 960.1])

排序

使用Python的内置函数sorted默认将字典中的键进行排序。

dicAreas={'Russia': 1707.5, 'Canada': 997.1, 'China': 960.1}
countries = sorted(dicAreas)
print(countries)
#['Canada', 'China', 'Russia']

合并

#字典1.update(字典2)
d1 = {'Russia': 1707.5, 'Canada': 997.1, 'China': 960.1}
d2 = {'USA':937.3, 'Russia':1709.8}
d1.update(d2) # 用d2更新d1
print(d1) # 同键，后值更新前值；不同键，键值对扩充入原字典
print(d2) # d2无变化
#{'Russia': 1709.8, 'Canada': 997.1, 'China': 960.1, 'USA': 937.3}
#{'USA': 937.3, 'Russia': 1709.8}


#dict(字典1, **字典2)		#**原来两个字典都不变**
d1 = {'Russia': 1707.5, 'Canada': 997.1, 'China': 960.1}
d2 = {'USA':937.3, 'Russia':1709.8}
d3 = dict(d1, **d2) # 同键，后值更新前值；不同键，键值对扩充入新字典
print(d3)
#{'Russia': 1709.8, 'Canada': 997.1, 'China': 960.1, 'USA': 937.3}

集合

存放一组无序且互不相同的元素
组成集合的元素必须是不可变类型，集合本身是可变的。
集合除了支持数学中的集合运算外，主要用来进行关系测试和消除重复元素

创建

直接创建集合，直接将元素放在一对大括号“{}”中；
用set函数创建空集合或将序列数据转换为集合。

s1 = {1,2,3}
s2 = set() # 创建空集合，不能用{}
s3 = set("hello") # 字符串转为集合，自动去重，{'h', 'o', 'l', 'e'}
s4 = set((1,3,2,3,5)) # 元组转为集合，自动去重，{1, 2, 3, 5}
s5 = { [1,2,3], 'a', 3, 1.2 } # TypeError: unhashable type: 'list'

访问

集合的元素是无序的，也没有键和值的概念，所以集合元素的访问要么通过集合名作整体输出，要么通过for循环实现元素遍历。

在这里插入图片描述

函数

定义

def 函数名([形参列表]):
    函数体

参数

#请输入人名：Tom
#请输入要说的话：hello
#请输入重复次数：3
#1.位置形参
def say(who, words, times):
    info = who + ' says:\"' + (words+" ")*times + '.\"'
    print(info)


who = input('请输入人名：')
words = input('请输入要说的话：')
times= eval(input('请输入重复次数：'))
say(who, words, times)

#2.默认形参
def say(who, words, times=1): # 默认参数必须定义在位置参数后面
    info = who + ' says:\"' + (words+" ")*times + '.\"'
    print(info)

say(who, words) # 未传入第三个参数，该参数取默认值

#3.关键字实参
#在调用函数时，按照key=value的形式为指定的参数传值，称为关键字实参。
def say(who, words, times=1): 
    info = who + ' says:\"' + (words+" ")*times + '.\"'
    print(info)
    
say(who, words=words) # 位置参数+关键字参数+默认参数

#4.可变参数
#在定义函数的时候，通过带一个星号的参数，可以向函数传递可变数量（甚至是0个）的参数
#调用函数时，从该参数之后所有的参数都被收集为一个元组。
def sum(*args): 
    total = 0
    for number in args:
        total += number
    return total

print(sum(1, 2, 3)) 
print(sum(12.5, 7.8, 22, 45.6))
#6
#87.9

#在定义函数的时候，可通过带两个星号的参数，向函数传递可变数量的参数，该参数之后所有参数都被收集为一个以实参名为key，实参值为value的字典
#调用函数时，实参形式为：key=value，key在传递时自动转为字符串，所以实参的key不要加引号。
def printCountries( **cs ):
    print(cs)
    for k,v in cs.items():
        print("{}的国土面积为{}万平方公里".format(k,v))
        
printCountries( Russia=1707.5, Canada=997.1, China=960.1 )
#{'Russia': 1707.5, 'Canada': 997.1, 'China': 960.1}
#Russia的国土面积为1707.5万平方公里
#Canada的国土面积为997.1万平方公里
#China的国土面积为960.1万平方公里

返回多个值

在函数体中使用return语句，可以返回一个值。
如果返回多个值，则默认打包成一个元组返回
当然，也可以将所有要返回的值置于一个序列对象（如列表）中返回

def fun(a,b):
    return a, b, a//b, a%b # 也可将所有返回值置于列表中：[a,b,a//b,a%b]

a = eval(input('a='))		#a=13
b = eval(input('b='))		#b=5
t = fun(a,b) # x,y,z = fun(a,b)		
print(f'{t[0]}和{t[1]}的商是{t[2]}，余数是{t[3]}')
#13和5的商是2，余数是3

lambda函数

lambda函数是一种简便的，在同一行定义函数的方法
lambda实际上是生成一个匿名函数对象，它广泛用于需要函数对象作为参数或函数比较简单并且只使用一次的场合
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值
lambda函数的定义格式：
- lambda 参数1，参数2，…… ：<函数语句>
  1. lambda 函数不能包含命令；
  2. 包含的语句不能超过一条

# 普通函数
def sum(x,y): 
    return x+y
print(sum(3,5))

# 为lambda函数命名
f = lambda x,y : x+y
# 利用该名称调用lambda函数
print( f(3,5) )

# 匿名lambda函数，边定义边调用
print((lambda x, y : x+y)(3,5))

# 带默认参数的lambda函数
print((lambda x, y=3 : x+y)(5))

filter函数

**filter(function,sequence)**函数是python内置的一个高阶函数
filter函数接收一个返回值为布尔值的函数对象和一个序列
这个函数的作用是将列表中的每个元素传入函数，将返回值为True 的元素放到一个可迭代filter对象中返回

lst = [3, 5, -7, 4, -1, 0, -9]
print(list(filter(lambda x: x<0, lst)))
#[-7, -1, -9]

map函数

map(function,sequence)：把sequence中的值当参数逐个传给function**，返回一个包含函数执行结果的map对象。**
如果function有两个参数，即map(function,sequence1,sequence2)

money = (1200, 1500, 800, 1000)
rate = [0.05, 0.04, 0.06, 0.03]
lst = list(map(lambda x,y:x*(1+y),money,rate))
print(lst)
#[1260.0, 1560.0, 848.0, 1030.0]

reduce函数

reduce(function,sequence)：function接收的参数个数只能为2，先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给function…，最后只返回一个结果。
python3 中，该函数被移到了functools模块中

print(reduce(lambda x, y: x * 10 + y, [1 , 2, 3, 4])) 
#1234
print(reduce(lambda x,y:x+y,range(1,101))) 
#5050
print(reduce(lambda x,y: x if x>y else y, [12,-2,17,4]))
#17

变量的作用域

每个变量都有自己的作用域，变量的作用域决定了该变量在当前域是否可访问
根据变量的作用域，Python的变量可分为“全局变量”和“局部变量”
- 局部变量：定义在函数体内部的变量
- 全局变量：定义在函数外部的变量
同名变量：
1. 局部没有，使用全局变量
2. 局部有，使用局部变量
3. 在局部中想用全局的，用global声明

def fun(): 
 return x + y # 全局变量x和y
x = 5 
y = 10 
z = fun()
print(x, y, z)


def fun(): 
 x = 7 # 局部变量x
 return x + y # 全局变量y
x = 5 
y = 10 
z = fun()
print(x, y, z)


def fun():
 global x # 声明全局变量x
 x = 10 # 全局变量x
 return x + y # 全局变量y
x = 5 
y = 10 
z = fun()
print(x, y, z)

文件

路径的表示
- 路径：F:\documents\python\5-1.py
- 路径字符串：“F:\\documents\\python\\5-1.py"
- 路径字符串：“F:/documents/python/5-1.py”
- 路径字符串：r"F:\documents\python\5-1.py"

模式字符

在这里插入图片描述

#将一个字符串写入文件的方法：
#文件对象.write(字符串)
#返回写入的字符数
file = open("e:/data.txt",'w') # 已有文件，则打开，否则新建
file.write(“Python\n”) # w方式从头开始写文件，a方式追加写
file.write("Java") # write不会自动换行，需加'\n'
file.close() # 不关闭或flush不会写出

#多个字符串写入文件的方法：
#文件对象.writelines(序列)
file = open("e:/data.txt",'w')
ls = ['Python','\n','Java']
file.writelines(ls)
file.close()

#从文件中读取内容的方法：
#字符串变量 = 文件对象.read()
#读出文件所有内容（包括换行符）作为一个字符串返回
file = open("e:/data.txt",'r')
content = file.read()
print(content)

#每次读一行文件内容：
#文件对象.readline()
#读文件中当前行（包括分隔符），并以字符串的形式返回
file = open("e:/data.txt",'r')
row = file.readline()
while row!='': # 文件结尾是空串
    print(row,end='')
    row = file.readline()
#读文件所有行：
#文件对象.readlines()
#读出文件所有内容（包括分隔符）并以列表返回，每行作为一个字符串元素放入列表
file = open("e:/data.txt",'r')
content = file.readlines()
print(content)

with open

Python引入with语句来自动调用close()方法

with open("e:/data.txt",'w') as f1:
    f1.write("Python\n")
    f1.write("Java")
    
with open("e:/data.txt",'r') as f1:
    content = f1.read()
    print(content)
    
    
with open("e:/data.txt",'r') as f1, open("e:/data2.txt",'w') as f2:
    content = f1.readlines()
    f2.writelines(content)