python3基础

print（）函数

支持自动换行：

不自动换行：使用   end=“”

print格式化输出

　　　　字符串格式化符号：

• %c 格式化字符及其ASCII码
• %s 格式化字符串
• %d 格式化整数
• %u 格式化无符号整型
• %o 格式化无符号八进制数
• %x 格式化无符号十六进制数
• %X 格式化无符号十六进制数（大写）
• %f 格式化浮点数字，可指定小数点后的精度
• %e 用科学计数法格式化浮点数
• %E 作用同%e，用科学计数法格式化浮点数
• %g %f 和 %e 的简写
• %G %f 和 %E 的简写

　　　　格式化操作符辅助指令：

• m.n. m 是显示的最小总宽度（如果指定的话）,n 是小数点后的位数(如果指定
的话)
• *定义宽度或者小数点精度
• -用做左对齐
• +在正数前面显示加号 +
• 在正数前面显示空格#
• 在八进制数前面显示零('0')
• 在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
• '%%'输出一个单一的'%'
• (var)映射变量(字典参数)

格式化输出：

如果想通过变量来填充格式控制字符串，那么可以使用运算符(%) 和一个元组， 在目标字符串中从左至右使用%：

使用字典来填充：

　　

变量与基本数据类型

变量使用之前一定要赋值，不需要加数据类型：

标识符

由数字，下划线，字母组成，不能以数字开头，区分大小写，支持中文符号：

保留字

数字数据类型

int 整型：0b、0o、0x分别表示二进制，八进制，十六进制，输出都是十进制表示，多条语句放在一行，可以用分号隔开：

支持非常长的整数：

float 浮点型：支持科学技术法

支持复数类型：a+bj  或者 complex(a,b)表示：

布尔类型：True  False

注释

单行注释：#

多行注释：''' 或者"""

运算符

算术运算

比较运算

赋值运算

 逻辑运算

字符串 

表示形式

可以用单引号或者双引号表示：

转义字符：

多行字符串可以通过三个连续的单引号(”’)或是双引号(“””)来进行标示:

字符串链接：

数字与字符串的区别：

查找 

find

语法：

注：

开始和结束位置下标可以省略，表示在整个字符串序列中查找

rfind  ：和find的功能相同，但查找方式为右侧开始

index

语法：

注：

开始和结束位置下标可以省略，表示在整个字符串序列中查找 

rindex：和index功能相同，但查找方向为右侧开始

count

返回某个子串在字符串中出现的次数 

"""
src = hello world and linux and python and java
find 和 rfind:
12
12
-1
33
12
-1
index 和 rindex:
12
12
33
12
count:
3
1
0
"""
src = 'hello world and linux and python and java'

print(f'src = {src}')
# index查找子串时，若没有找到，返回-1
print('find 和 rfind:')
print(src.find('and'))
print(src.find('and',5,20))
print(src.find('ands'))
print(src.rfind('and'))
print(src.rfind('and',5,20))
print(src.rfind('ands'))


print('index 和 rindex:')
# index查找子串时，若没有找到，则报错
print(src.index('and'))
print(src.index('and',5,20))
print(src.rindex('and'))
print(src.rindex('and',5,20))

print('count:')
# index查找子串时，若没有找到，返回0
print(src.count('and'))
print(src.count('and',5,20))
print(src.count('ands'))

修改

replace

语法：

"""
replace:
hello world + linux + python + java
hello world + linux + python and java
hello world + linux + python + java
"""
src = 'hello world and linux and python and java'

print(f'src = {src}')
# replace返回修改后的字符串
print('replace:')
new_src = src.replace('and','+')
print(new_src)
new_src = src.replace('and','+',2)
print(new_src)
new_src = src.replace('and','+',10)
print(new_src)

split

语法：

"""
split:
['hello world ', ' linux ', ' python ', ' java']
['hello world ', ' linux ', ' python and java']
"""
src = 'hello world and linux and python and java'

# split返回的是一个列表，num表示的是分割字符出现的次数，则返回数据个数为num+1
print('split:')
new_src = src.split('and')
print(new_src)
new_src = src.split('and',2)
print(new_src)

join

语法：

"""
join:
hello$$$$world$$$$and$$$$linux$$$$and$$$$python$$$$and$$$$java
"""
src = ['hello','world','and','linux','and','python','and','java']

# split返回的是一个列表，num表示的是分割字符出现的次数，则返回数据个数为num+1
print('join:')
new_src = '$$$$'.join(src)
print(new_src)

capitalize

"""
capitalize:
Hello world and linux and python and java
"""
src = 'hello world and Linux and Python and Java'

# capitalize 函数转换后，只字符串第一个字符大写，其他的全部小写
print('capitalize:')
new_src = src.capitalize()
print(new_src)

title

"""
title:
Hello World And Linux And Python And Java
"""
src = 'hello world and Linux and Python and Java'

# title 将字符串的每个单词首字母转换成大写
print('title:')
new_src = src.title()
print(new_src)

lower

"""
lower:
hello world and linux and python and java
"""
src = 'hello world and Linux and Python and Java'

# lower 将字符串中大写转换成小写
print('lower:')
new_src = src.lower()
print(new_src)

upper

"""
upper:
HELLO WORLD AND LINUX AND PYTHON AND JAVA
"""
src = 'hello world and Linux and Python and Java'

# upper 将字符串中大写转换成小写
print('upper:')
new_src = src.upper()
print(new_src)

lstrip

删除字符左侧空白字符

"""
  hello world and Linux and Python and Java   
hello world and Linux and Python and Java 
"""
src = '  hello world and Linux and Python and Java   '

print(src)
new_src = src.lstrip()
print(new_src)

rstrip

删除字符右侧空白字符

"""
  hello world and Linux and Python and Java   
  hello world and Linux and Python and Java
"""
src = '  hello world and Linux and Python and Java   '

print(src)
new_src = src.rstrip()
print(new_src) 

strip

删除字符两侧空白字符 

"""
  hello world and Linux and Python and Java   
hello world and Linux and Python and Java
"""
src = '  hello world and Linux and Python and Java   '

print(src)
new_src = src.strip()
print(new_src)

ljust

返回一个字符串左对齐，并使用指定的字符（默认空格）填充至对应长度的新字符串

语法：

src = 'hello'
src.ljust(10,'.')
'hello.....'
src.ljust(10,'*')
'hello*****'
src.ljust(10)
'hello

rjust

返回一个字符串右对齐，并使用指定的字符（默认空格）填充至对应长度的新字符串

src = 'hello world'
src.rjust(15)
'    hello world'
src.rjust(15,'#')
'####hello world'

center

返回一个字符串居中对齐，并使用指定的字符（默认空格）填充至对应长度的新字符串

src = 'hello world'
src.center(15,'#')
'##hello world##'
src.center(15)
'  hello world  '
src.center(16,'#')
'##hello world###' 

判断

startswith

检测字符串是否以指定字串开头，是则返回true，否则返回false，若设置开始和结束位置下标，则在指定范围内检查

语法：

"""
hello world and Linux and Python and Java
True
False
"""
src = 'hello world and Linux and Python and Java'

print(src)
new_src = src.startswith('hello')
print(new_src)
new_src = src.startswith('hello',5,20)
print(new_src)

endswith

检测字符串是否以指定字串结束，是则返回true，否则返回false，若设置开始和结束位置下标，则在指定范围内检查 

"""
hello world and Linux and Python and Java
True
False
"""
src = 'hello world and Linux and Python and Java'

print(src)
new_src = src.endswith('Java')
print(new_src)
new_src = src.endswith('Java',5,15)
print(new_src)

isalpha

如果字符串至少有一个字符并且所有字符都是字母则返回true，否则返回false

"""
helloworld
hello110
True
False
"""
src1 = 'helloworld'
src2 = 'hello110'

print(src1)
print(src2)
print(src1.isalpha())
print(src2.isalpha())

isdigit

如果字符串中只包含数字则返回true，否则返回false

"""
110
hello110
True
False
"""
src1 = '110'
src2 = 'hello110'

print(src1)
print(src2)
print(src1.isdigit())
print(src2.isdigit())

isalnum

若字符串至少有一个字符并且所有字符都是字母或数字则返回true，否则返回false

"""
110**
hello110
False
True
"""
src1 = '110**'
src2 = 'hello110'

print(src1)
print(src2)
print(src1.isalnum())
print(src2.isalnum())

isspace

若字符串质保函空白，则返回true，否则返回false

"""  
hello110
True
False
"""
src1 = '   '
src2 = 'hello110'

print(src1)
print(src2)
print(src1.isspace())
print(src2.isspace())

下标

类似数组下标

"""
helloworld
src[1]=e
"""
src = 'helloworld'

print(src)
print(f'src[1]={src[1]}')

切片

对操作的对象截取其中一部分的操作，对面是：字符串、列表、元组

语法：

注意：

1、不包括结束位置下标对应的数据，正负数均可

2、步长是选取间隔，正负整数均可，默认步长为1

# 序列号【开始位置下标：结果位置的下标：步长】
"""
345
345
123
456789
543
97
"""
str = '123456789'

print(str[2:5:1])
print(str[2:5])   # 默认步长为1

print(str[:3])
print(str[3:])

# 下标为-1表示最后一个数据、步长为负数，表示倒叙选取
print(str[4:1:-1])
print(str[-1:-4:-2])

列表

列表基础介绍

列表中元素的类型可以不相同，数据可修改，它支持数字，字符串甚至可以包含列表：

列表元素访问：

切片截取：

切片步长：

嵌套访问字符串：

查找

下标

"""
world
"""
src1 = ['hello','world','python']

print(src1[1])

index

返回指定数据所在位置的下标

语法：

"""
1
1
"""
src1 = ['hello','world','python']

# 若查找不到，则报错
print(src1.index('world'))
print(src1.index('world',1,15))

count

统计指定数据在列表中出现的次数

"""
1
"""
src1 = ['hello','world','python']

# 若查找不到，则返回0
print(src1.count('world'))　

len

求列表中数据的个数

"""
3
"""
src1 = ['hello','world','python']

# 若为空，则返回0
print(len(src1)) 

in

判断指定数据在列表中是否存在，若存在返回true，否则返回flase

not in

判断指定数据在列表中是否存在，若不存在返回true，否则返回flase

"""
True
False
False
True
"""
src1 = ['hello','world','python']

print('hello' in src1)
print('sh' in src1)

print('hello' not in src1)
print('sh' not in src1)

案例：

src1 = ['Tom','Jam','Pam']

name = input('请输入你要搜索的名字：')

if name in src1:
    print(f'你输出的名字是：{name},已经存在')
else:
    print(f'您输出的名字是{name},名字不存在')

增加

append

列表追加数据，若追加的是一个序列，则追加整个序列到列表中

语法：

"""
['Tom', 'Jam', 'Pam', 'KK']
['Tom', 'Jam', 'Pam', 'KK', ['YY', 'GG']]
"""
src1 = ['Tom','Jam','Pam']

src1.append('KK')
print(src1)
src1.append(['YY','GG'])
print(src1)

extend

列表追加数据，若追加的是一个序列，则追加整个序列的数据到列表中

"""
['Tom', 'Jam', 'Pam', 'K', 'K']
['Tom', 'Jam', 'Pam', 'K', 'K', 'YY', 'GG']
"""
src1 = ['Tom','Jam','Pam']

src1.extend('KK')
print(src1)
src1.extend(['YY','GG'])
print(src1)

insert

指定位置新增数据

语法：

"""
['Tom', 'Jam', 'KK', 'Pam']
"""
src1 = ['Tom','Jam','Pam']

src1.insert(2,'KK')
print(src1)

删除 

del

删除整个列表

语法：

"""
['Tom', 'Jam']
报错
"""
src1 = ['Tom','Jam','Pam']
del src1[2]
print(src1)
del src1
print(src1)

pop

删除指定下标的数据，若不指定，默认删除最后一个数据。然后返回被删除的数据

"""
Pam
['Tom', 'Jam']
Jam
['Tom']
"""
src1 = ['Tom','Jam','Pam']

new_src1 = src1.pop()
print(new_src1)
print(src1)
new_src1 = src1.pop(1)
print(new_src1)
print(src1)

remove

删除列表某个数据的第一个匹配项

语法：

"""
['Tom', 'Pam', 'Jam']
"""
src1 = ['Tom','Jam','Pam','Jam']

src1.remove("Jam")
print(src1)

clear

清空列表

"""
[]
"""
src1 = ['Tom','Jam','Pam','Jam']

src1.clear()
print(src1)

修改

修改指定下标数据

"""
['Tom', 'Jam', 'Pam', 'LL']
"""
src1 = ['Tom','Jam','Pam','Jam']

src1[3] = 'LL'
print(src1)

reverse

逆序列表数据

"""
[6, 5, 4, 3, 2, 1]
"""
src1 = [1,2,3,4,5,6]

src1.reverse()
print(src1)

sort

语法：

注释：reverse = true：降序、reverse = false：升序【默认】

"""
[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6]
"""
src1 = [1,2,3,4,5,6]

src1.sort()
print(src1)
src1.sort(reverse=True)
print(src1)
src1.sort(reverse=False)
print(src1)

复制

copy

复制列表

"""
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
"""
src1 = [1,2,3,4,5,6]

new_src1 = src1.copy()
print(src1)
print(new_src1)

循环遍历

依次打印列表的数据

while

"""
1
2
3
4
5
6
"""
src1 = [1,2,3,4,5,6]
i = 0

while i < len(src1):
    print(src1[i])
    i += 1

for

"""
1
2
3
4
5
6
"""
src1 = [1,2,3,4,5,6]

for i in src1:
    print(i)

列表嵌套

"""
[[1, 2, 3, 4, 5, 6], ['Pam', 'Jam'], ['$', '*', '&']]
['Pam', 'Jam']
Jam
"""
src1 = [[1,2,3,4,5,6],['Pam','Jam'],['$','*','&']]

print(src1)
print(src1[1])
print(src1[1][1])

综合案例：将8个老师随机分配到3个办公室中

"""
1、准备数据
    8位老师列表
    3个办公室
2、分配老师到办公室
    随机分配
        把老师的名字写入办公室列表中
3、验证是否分配成功
    打印办公室详细信息：每个办公室的人数和对应的老师名字
输出：
办公室1的人数是3，老师分别是：
a
w
r
办公室2的人数是3，老师分别是：
t
b
g
办公室3的人数是2，老师分别是：
q
e
"""
import  random

teachers = ['a','q','w','e','r','t','b','g']
offices = [[],[],[]]

for name in teachers:
    num = random.randint(0,2)
    offices[num].append(name)

i = 1
for office in offices:
    print(f'办公室{i}的人数是{len(office)}，老师分别是：')
    for name in office:
        print(name)
    i += 1

Tuple元组

元组（tuple）与列表类似，不同之处在于元组的元素不能修改

元组定义

"""
<class 'int'>
<class 'tuple'>
<class 'str'>
<class 'tuple'>
"""

src = (1)
src1 = (1,)
print(type(src))
print(type(src1))

src2 = ('s')
src3 = ('s',)
print(type(src2))
print(type(src3))

操作

按下标查找数据

"""
3
"""

src = (1,2,3,4,5)
print(src[2])

index

查找数据位置，若数据存在，则返回对应的下标，否则报错

"""
2
"""

src = (1,2,3,4,5)
print(src.index(3))

count

统计指定数据出现的次数

"""
2
"""

src = (1,2,3,2,5)
print(src.count(2))

len

统计元组中数据的个数

"""
5
"""

src = (1,2,3,2,5)
print(len(src))

Set集合

集合创建

集合（set）是一个无序、且不含重复元素的序列 集合主要用来进行成员关系测试和删除重复元素 可以使用大括号 { } 或者 set() 函数 创建集合，但创建空集合时只能用set（）函数，因为｛｝是用来创建空字典的

"""
<class 'set'>
{1, 2, 3, 4, 5}
<class 'set'>
{'f', 'a', 'd', 's'}
<class 'set'>
set()
<class 'dict'>
{}
"""
set1 = {1,2,3,4,5,1,2}

print(type(set1))
print(set1)

set2 = set('asdasfas')
print(type(set2))
print(set2)

set3 = set()
print(type(set3))
print(set3)

set4 = {}
print(type(set4))
print(set4)

增

add

追加数据，若已有，则不变化

update

追加序列，若是单一数据，报错

"""
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 100}
{1, 2, 3, 4, 5, 100}
{1, 2, 3, 4, 5, 100, 200, 300}
报错
"""
set1 = {1,2,3,4,5,1,2}

print(set1)
set1.add(100)
print(set1)
set1.add(1)
print(set1)

set1.update([200,300])
print(set1)
set1.update(500)
print(set1)

删

remove

删除集合中指定的数据，若不存在，则报错

discard

删除集合中指定的数据，若不存在，则不变

pop

随机删除某个数据，并返回删除的数据

"""
{1, 2, 3, 4, 5}
{1, 3, 4, 5}
报错
{1, 3, 4, 5}
{1, 3, 4, 5}
{3, 4, 5}
{4, 5}
"""
set1 = {1,2,3,4,5,1,2}

print(set1)
set1.remove(2)
print(set1)
set1.remove(2)
print(set1)

set1.discard(2)
print(set1)
set1.discard(2)
print(set1)

set1.pop()
print(set1)
set1.pop()
print(set1)

查

in

判断数据是否在集合中

not in

判断数据是否不在集合中

"""
True
False
False
True
"""
set1 = {1,2,3,4,5,1,2}

print(3 in set1)
print(66 in set1)

print(3 not in set1)
print(66 not in set1)

字典

字典的创建

1、直接赋值

2、通过dict 

例如：创建一个空字典

dict1 = ｛｝或者  dict1 = dict（）

字典是一种映射类型，用"{ }" 标识，它是一个无序的  键(key) : 值(value)对  集合 键   键(key) 必须使用不可变类型，在同一个字典中，键(key) 是唯一的【字典可以为空】

增

语法：

字典序列[key] = 值

注释：如果key存在则修改这个key对应的值，若不存在，则新增此键值对

"""
{'name': 'Pam', 'age': 25, 'sex': 'man'}
{'name': 'Pam', 'age': 23, 'sex': 'man'}
{'name': 'Pam', 'age': 23, 'sex': 'man', 'id': 110}
"""

dict1 = {'name':'Pam','age':25,'sex':'man'}

print(dict1)
dict1['age'] = 23
print(dict1)
dict1['id'] = 110
print(dict1)

删

del（）或 del

删除字典 或 删除字典中指定的键值对

clear

清空字典

"""
{'name': 'Pam', 'age': 25, 'sex': 'man'}
{'name': 'Pam', 'sex': 'man'}
{}
报错
"""

dict1 = {'name':'Pam','age':25,'sex':'man'}

print(dict1)
del dict1['age']
print(dict1)
dict1.clear()
print(dict1)
del dict1
print(dict1)

改

和增一样

查

key值查找

若当前查找的key存在，则返回对应的值，否则报错

"""
{'name': 'Pam', 'age': 25, 'sex': 'man'}
Pam
报错
"""

dict1 = {'name':'Pam','age':25,'sex':'man'}

print(dict1)
print(dict1['name'])
print(dict1['id'])

get

语法：

注释：

若当前查找的key不存在，则返回第二个参数（默认值），若省略第二个参数，则返回None

"""
{'name': 'Pam', 'age': 25, 'sex': 'man'}
Pam
110
None
"""

dict1 = {'name':'Pam','age':25,'sex':'man'}

print(dict1)
print(dict1.get('name'))
print(dict1.get('id',110))
print(dict1.get('id'))

keys

values

items

"""
{'name': 'Pam', 'age': 25, 'sex': 'man'}
dict_keys(['name', 'age', 'sex'])
dict_values(['Pam', 25, 'man'])
dict_items([('name', 'Pam'), ('age', 25), ('sex', 'man')])
"""

dict1 = {'name':'Pam','age':25,'sex':'man'}

print(dict1)
print(dict1.keys())
print(dict1.values())
print(dict1.items())

循环遍历

遍历key

"""
name
age
sex
"""
dict1 = {'name':'Pam','age':25,'sex':'man'}

for key in dict1.keys():
    print(key)

遍历value

"""
Pam
25
man
"""
dict1 = {'name':'Pam','age':25,'sex':'man'}

for value in dict1.values():
    print(value)

遍历item

"""
('name', 'Pam')
('age', 25)
('sex', 'man')
name = Pam
age = 25
sex = man
"""
dict1 = {'name':'Pam','age':25,'sex':'man'}

for item in dict1.items():
    print(item)

for key, value in dict1.items():
    print(f'{key} = {value}')

字典内置函数：

类型转换

数据类型的转换，只需要将数据类型作为函数名即可使用    如： int(), float(),  和 str()

字符和数字的转换，通过 ord()  和 chr():

表达式字符串到数值的转换：

python 的行

Python 中没有强制的语句终止字符　　Python 语句中一般以新行（换行）作为语句的结束符 【可以使用 多行连接符： 斜杠（ ）将一行的语句分为多行显示】：

流程控制

条件语句　

if 条件表达式：

语句块1

if 条件表达式：

语句块1

else：

语句块2

if 条件表达式1：

语句块1

elif 条件表达式2 ：

语句块2

else:

语句块3

循环语句

while 条件表达式:

语句

统计6出现在2的100次方中的次数：

for 循环变量 in 序列:

语句块

使用for和range来枚举列表中的元素：

多重循环：

九九乘法表：

列表推导式

列表推导式(List Comprehension) 提供了一个创建和操作列表的有力工具【列表推导式由一 个表达式以及紧跟着这个表达式的for 语句构成，for 语句　还可以跟0 个或多个if 或for 语句】

数值判断可以链接使用，例如 1<x<3  能够判断变量 x 是否在1 和3 之间 :

break语句

break 语句用在while 和for 循环中 break 语句用来终止循环语句，即循环条件没有False 或者序列还没被完全 递归完，也会停止执行循环语句

统计在2的100次方中首次出现6的位置：

在嵌套循环中，break 语句将停止执行本层的循环：

求2—20之间的素数：

continue  语句

用来跳过当前循环的剩余语句，然后继续进行下一轮循环：

删除2的100次方中的9：

pass  语句

是空语句，是为了保持程序结构的完整性，一般用做占位语句

函数　　

函数定义语法

def functionname( parameters ):
　　"函数_文档字符串"
　　function_suite
　　return [expression]     【不带表达式的 return相当于返回 None】

 　　　　　　　　打印从0-9的阶乘表，每行两个：

函数参数

可选参数以集合的方式出现在函数声明中并紧跟着必选参数，可选参数可以在函数声明中被赋予一个默认值。已命名的参数需要赋值。

函数的第一行语句可以选择性地使用文档字符串 —用于存放函数说明
函数可以返回一个元组（使用元组拆包可以有效返回多个值）

全局变量和局部变量

全局变量在函数之外声明
局部变量在函数内容声明
函数参数也是局部变量，不需要在函数内部重复定义！！！
全局变量可以不需要任何特殊的声明即能读取，但如果想要修改全局变量的
值，就必须在函数开始之处用global关键字进行声明，否则Python会将此
变量按照新的局部变量处理

函数说明文档

语法：

使用：

"""
sum_1(a, b)
    求和函数：
    :param a:
    :param b:
    :return:
"""
def sum_1(a,b):
    """
    求和函数：
    :param a:
    :param b:
    :return:
    """
    return a + b

help(sum_1)

函数返回值

函数可以有多个返回值，且return后直接可书写 元组、列表、字典等

"""
(1, 2)
"""
def sum_1(a,b):
    return (a,b)

re = sum_1(1,2)
print(re)

参数

位置参数

关键字参数

注释：位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

def info(name,age,sex):
    print(f'你的名字是{name}，年龄是{age}，性别是{sex}')

info('pam',age=20,sex='man')
# 位置参数在关键字参数之后，报错
info(age=22,sex="woman",'sh')

缺省参数

又叫 “默认参数”

注释：所有位置参数必须出现在默认参数前，包括函数定义和调用

"""
你的名字是pam，年龄是20，性别是man
你的名字是sh，年龄是22，性别是woman
"""
def info(name,age,sex = 'man'):
    print(f'你的名字是{name}，年龄是{age}，性别是{sex}')

info('pam',age=20)
# 缺省参数传值则修改默认参数值
info('sh',sex="woman",age=22)

不定长参数

包裹位置传递

注释：传入的所有参数被args'变量收集，根据传入的参数的位置合并成一个元组

"""
('pam', 20)
('sh', 'woman', 22)
()
"""
def info(*args):
    print(args)

info('pam',20)
info('sh',"woman",22)
info()

包裹关键字传递

注释：关键字传递返回的是一个字典，无论是包裹位置还是包裹关键字传递，都是一个组包的过程

"""
{'name': 'pam', 'age': 20}
{'name': 'sh', 'sex': 'woman', 'age': 22}
{}
"""
def info(**kargs):
    print(kargs)

info(name = 'pam',age = 20)
info(name = 'sh',sex = "woman",age = 22)
info()

拆包

拆包元祖

"""
10
20
"""
def rerurn_info():
    return 10,20

num1, num2 = rerurn_info()
print(num1)
print(num2)

拆包字典

"""
name
age
pam
20
"""
dict1 = {'name':'pam','age':20}

num1, num2 = dict1

#取出key值
print(num1)
print(num2)
# 取出value值
print(dict1[num1])
print(dict1[num2])

交换变量值

"""
a = 5,b = 6
a = 6,b = 5
a = 1,b = 2
a = 2,b = 1
"""
# 方法一：借助第三变量
c = 0
a = 5
b = 6
print(f'a = {a},b = {b}')
c = a
a = b
b = c
print(f'a = {a},b = {b}')

# 方法二：快速交换
a, b = 1, 2
print(f'a = {a},b = {b}')
a ,b = b, a
print(f'a = {a},b = {b}')

引用

python中值都是靠引用来传递的

注释：id（）：用来判断两个变量是否为同一个值的引用

"""
140708132607680
140708132607680
"""
a = 22
b = a

print(id(a))
print(id(b))

可变和不可变类型

可变类型：

列表

字典

集合

不可变类型：

整型

浮点型

字符串

元组

类class

类（Class）用来描述具有相同的属性和方法的对象的集合
它定义了该集合中每个对象所共有的属性和方法
对象是类的实例

class ClassName:
　　'类的帮助信息' #类文档字符串
　　class_suite #类体  【class_suite 由类成员，方法，数据属性组成】

实例化和调用：

文件

读写文件：

异常

Python中的异常由 try-except [exceptionname] 块处理：

导入外部库　　

外部库可以使用 import [libname] 关键字来导入
可以用 from [libname] import [funcname] 来导入所需要的函数

获取帮助信息

　　调用dir()来显示该对象的所有方法

 　　调用help()会显示其文档