python课堂笔记1基础知识
课堂笔记
用书：《python编程从入门到实践》
基础语法
变量
命名
变量名仅限于英文字母、数字及下划线；其中数值部分不允许以零开头。可用下划线连接词。
变量名只是一个标签
数据类型
不可变数据：Number数字、String字符串、Tuple元组
可变数据：List列表、Dictionary字典、Set集合
数字number
1.整型int
使用^符号进行指数运算时, 例如x^y即代表x的y次幂。
除法有两种运算符, 使用/操作会得到浮点数值, 而通过//操作会得到整数值.
2.浮点型float
该运算中涉及的小数精度可能不够精确
这两个数字相除得到的结果是浮点数值.
3.复数complex
4.bool
字符串string
用单引号或双引号括起的都是字符串
常用内置函数
修改字符串的大小写
'''
1.title()将每个单词的首字母改为大写
2.upper()全大写
3.lower()全小写
'''
name = "ada lovelace"
print(name.title())
name = "Ada Lovelaces"
print(name.upper())
print(name.lower())
'''
输出： Ada Lovelace
ADA LOVELACES
ada lovelaces
'''合并（拼接）字符串
'''
使用+合并字符串
'''
first_name = "ada"
last_name = "lovelaces"
full_name = first_name + " " + last_name
print(full_name)
#输出：ada lovelaces删除空白
'''
rstrip()删除末尾空白
lstrip()删除前端空白
strip()删除两端空白
这种删除是暂时的，要永久删除空白就要将删除操作的结果存到变量中
'''
>>>favorite_language = ' python '
>>>favorite_language.rstrip()
' python'
>>>favorite_language.lstrip()
'python '
>>>favorite_language.strip()
'python'- 字符串里面的空白用replace(" “,”")删除
连接 +
字符串和数字的拼接
Python 语言不支持将数字与字符串进行直接拼接操作, 因此我们需要先把数字转换为字符串类型以便后续的操作
name = ”小明“
age = 8
info = name + "已经" + str(age) + "岁了"截取字符串（字符串切片）
获取单个字符
Python 允许从字符串的两端使用索引：
- 当选择字符序列的第一字符作为起始位置时，则该序列的位置标记将基于零值进行计算；
- 当选择字符序列的最后一字符作为起始基准时，则该序列的位置标记将基于负数值表示；
a = "hello,world"
print(a[6])
print(a[-5])获取多个字符
strname[start : end : step]
url = "https://www.baidu.com/"
print(url[12:17])
print(url[12:-5])
print(url[6:19:3])
print(url[12:])
print(url[:17])
print(url[::3])分割字符串
该split()方法能够完成将一个字符串按照指定分隔符分割成多个子串，并将这些子串以列表形式存储在结果变量中（不包含原始分隔符），作为该方法的返回值输出。
str.split(sep,maxsplit)
在未指定 sep 参数时，split() 方法默认采用空字符进行分割。
maxsplit：可选参数，在分割操作中决定每一步如何处理数据。使用该参数后会生成一个列表序列，在该序列中包含的数据子串数量最多有maxsplit+1个。若未指定该参数或设为-1时，则表示分割操作无限制。
str = "百度 >>> www.baidu.com"
list1 = str.split()
print(list1)
list1 = str.split('>>>')
print(list1)
list1 = str.split('.')
print(list1)
list1 = str.split('>',3)
print(list1)合并字符串
在调用join()方法进行字符串合并时
newstr = str.join(iterable)
newstr：表示合并后生成的新字符串；
str：用于指定合并时的分隔符；
iterable：做合并操作的源字符串数据，允许以列表、元组等形式提供。
list = ['www','baidu','com']
new_list = '.'.join(list)
print(newlist)统计字符串出现的次数
count() 方法用于统计指定字符串在另一字符串中的发生频率，并接受两个参数：一个是要统计的字符串和一个是要检查的字符串。若要统计的字符串不存在，则返回 0；否则返回该字符串在另一个字符串中的重复次数。
str.count(sub[,start[,end]])
str = "www.baidu.com"
str.count('.')
str.count('.'3)
str.count('.',4)
str.count('.',4-4)
str.count('.',4,-5)检测字符串中是否包含某子串
find() 方法用于查找字符串中是否存在目标字符串。若存在，则会给出最早出现的位置；否则则返回-1。
str.find(sub[,start[,end]])
str = "www.baidu.com"
str.find('.')
str.find('.',4)
str.find('.',4,-5)如同find()方法一样, index()方法也可用于判断列表中是否包含指定的字符串.主要区别在于:当查询的目标字符串不在列表中时, index()方法会导致程序报错.
str = "www.baidu.com"
str.index('.')
str.index('e')startswith()&endswith()
startswith() 方法用于判断输入字符串是否以指定字符串开头，并根据结果返回True或False
str = "baidu.com"
str.startswith("c")
str.startswith("www")
str.startswith("i",2)该方法被用来判断一个字符串是否以特定的子串结束。如果满足条件，则会返回布尔值True；否则将不会执行该操作并直接返回布尔值False。
str = "baidu.com"
str.endswith("com")大小写转换
title()方法负责对每个单词应用首字母大写字体处理，并使其余全部变为小写字体。
lower() 方法用于将字符串中的所有大写字母转换为小写字母。
该函数的作用与其相对应的功能恰好相反；其主要作用是将字符串中的所有小写字母转换为大写字母。
swapcase()将字符串中大写转换为小写，小写转换为大写
str = "Hello,wang xiaoming"
print(str.title())
print(str.lower())
print(str.upper())
print(str.swapcase())文本对齐
Python中的str类型提供了三种方法用于实现文本对齐功能，默认情况下分别为ljust()、rjust()和center()函数
该ljust()方法的作用是将给定字符串的右侧进行填充，并以实现文本左对齐为目标。
rjust()函数用于将字符串的左侧填充指定字符以实现文本的右对齐效果。
center() 让文本居中
str = "https://www.baidu.com/"
str1 = "www.baidu.com"
print(str.ljust(25)) #rjust();center()
print(str1.ljust(25))
print(str.ljust(25,'-'))
print(str1.ljust(25,'-'))去除字符串中空格（删除指定字符）
- strip()函数用于去除字符串两边的空格或其他非主体字符。
- lstrip()方法专门用于去除文本左侧多余的空格或其他非关键符号。
- rstrip则负责去除文本末尾部分多余的空白或其他非主要字符。
这里的特殊字符，指的是制表符（\t）、回车符（\r）、换行符（\n）等。
str = " baidu.com \t\n\r"
print(str.strip()) #lstrip(),rstrip()
print(str.strip(" ,\r"))替换
replace(old, new, count）
- 原始字符或字符串
- 新符号
- 最大替换次数是从指定起始位置开始计算的，默认情况下会将所有符合条件的字符进行替换
- 特别提示：replace函数用于将指定范围内的原始字符替换为新符号，并且不会影响到未被处理的部分
s1 = '2021.3.19'
s2 = s1.replace('.','-')
print(s2)
s3 = s1.replace('.','-',1)
print(s3)
s4 = s1.replace('.19',' ')
print(s4)格式化
% 表示开始一个注释段落
采用 %5d 的语法进行右对齐设置，默认占位符为 width=5
采用 % -width alignment syntax for right-aligned padding 使用 %05d实现反转居中格式化 在应用%4.2f` 格式说明符时，默认保留两位小数值；若需调整精度可指定所需的小数值参数
print('我叫%s,身高%scm'%(name,height))- format
print('name is {}, age is {}'.format('Tom',12))
print('name is {1}, age is {0}'.format(12,'Tom'))
print('name is {name}, age is {age}'.format(name = 'Tom', age = 20))
##左对齐< 右对齐> 中间对齐^
print('name is {0:*<11},age is {1:0>11},gender is {3:_^11}'.format('Tom',12,'male'))#所占宽度为11，长度不足分别用*，0，_补足- f
name = 'Tom'
age = 12
print(f'name is {name},age is {age}')列表List []
列表：有序集合 （很像数组）
列表中的元素不一定是同一类型
bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)
print(bicycle[0])
print(bicycle[-1]) #访问最后一个列表元素
print(bicycle[-2]) #访问倒数第二个
'''
输出：['trek', 'cannondale', 'redline', 'specialized']
trek
specialized
redline
'''在列表中添加/删除元素
'''
1.在列表末尾添加元素：append()
2.在列表中插入元素：insert(x,'A') 将A插入到下标为x的元素前面【添加的元素作为列表的第x个元素】
3.在列表中删除元素：del 将值删除后无法再访问它
pop() 删除列表中的元素并返回这个元素
remove(data) 只知道要删除元素的值不知道它所处的位置时使用，使用remove()从列表中删除元素时，也可接着使用它的值。如果列表中有多个data，则需要删除多次
'''
motorcycles = []
motorcycles.append('honda')
motorcycles.append('yamaha')
motorcycles.append('suzuki')
print(motorcycles)
motorcycles.insert(0, 'ducati')
print(motorcycles)
del motorcycles[0]
print(motorcycles)
a = motorcycles.pop(1) #a = motorcycles.pop()表示删除列表末尾的值
print(motorcycles)
print(a)
b = 'honda'
motorcycle.remove(b)
print(motorcycles)
print(b.upper())
'''
输出：['honda', 'yamaha', 'suzuki']
['ducati', 'honda', 'yamaha', 'suzuki']
['honda', 'yamaha', 'suzuki']
['honda', 'suzuki']
yamaha
['suzuki']
HONDA
'''组织列表（调整排列顺序）
'''
1.对列表进行永久性排序：list.sort()
2.对列表进行临时排序【函数的方法】：sorted(list) 按特定顺序显示列表元素同时不影响它们在列表中的原始排列顺序。【不改变列表list，返回一个排序的列表。】
3.反转列表元素顺序：list.reverse()
4.获取列表长度：len(list) 【返回列表的元素数目】
'''
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort() #按字母顺序排序
print(cars)
cars.sort(reverse=True) #按与字母顺序相反的顺序排列
print(cars)
'''
输出：['audi', 'bmw', 'subaru', 'toyota']
['toyota', 'subaru', 'bmw', 'audi']
'''
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
print(sorted(cars))
print(cars)
'''
输出：['bmw', 'audi', 'toyota', 'subaru']
['audi', 'bmw', 'subaru', 'toyota']
['bmw', 'audi', 'toyota', 'subaru']
'''
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)
'''
输出：['bmw', 'audi', 'toyota', 'subaru']
['subaru', 'toyota', 'audi', 'bmw']
'''遍历列表（for循环）
magicians = ['alices', 'david', 'carolina']
for magician in magicians:
print(magician.title() + ", that was a great trick!")
print("Thank you, everyone")
#注意缩进和冒号，尤其是冒号！！！！创建数值列表
#range()
for value in range(1,5):
print(value)
'''
输出：1
2
3
4
'''
-----------------------------------------
#使用range()创建数字列表
numbers = list(range(1, 6))
print(numbers)
#输出：[1, 2, 3, 4, 5]
-----------------------------------------
#打印1-10的偶数
even_number = list(range(2, 11, 2)) #步长为2
print(even_number)
#输出：[2, 4, 6, 8, 10]
-----------------------------------------
#将前10个整数添加到一个列表中
squares = []
for value in range(1,11):
square = value**2 #squares.append(value**2)
squares.append(square)
print(squares)
#输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
------------------------------------------
'''
对数字列表执行简单的计算
min() max() sum()
'''
digits = [1, 3, 5, 7, 9, 11]
print(min(digits))
print(max(digits))
print(sum(digits))
'''
输出：1
11
36
'''
-------------------------------------------
'''
列表解析：将for循环和创建新元素的代码合并成一行，并自动附加新元素
'''
squares = [value**2 for value in range(1, 11)]
print(squares)
#输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]使用列表的一部分
切片 [1:3]
list[j:k] 从列表第j个元素到第k-1个元素的子列表
list[:k] 从列表开始到第k-1个元素
list[j:] 从第j个元素到最后一个元素
list[-3:] 列表最后三个元素的子列表
list[-3:-1] 列表最后两个元素的子列表
list[5:-1] 从第5个到倒数第二个元素
players = ['a', 'b', 'c', 'd', 'e']
print(players[1:3]) # 和range一样，在到达第二个索引前面的元素后停止
print(players[:4]) # 没有指定第一个索引，则自动从头开始
print(players[2:]) # 终止于列表末尾
print(players[-2:]) # 负数索引返回离列表末尾相应距离的元素
'''
输出：['b', 'c']
['a', 'b', 'c', 'd']
['c', 'd', 'e']
['d', 'e']
'''
---------------------------------------------
#遍历切片
players = ['a', 'b', 'c', 'd', 'e']
for player in players[1:4]:
print(player.upper())
'''
输出：B
C
D
'''复制列表[:]
创建一个包含整个列表的切片，同时省略起始索引和终止索引[:]
#使用切片创建了a的副本，再将该副本存储到变量b中
a = ['apple', 'pear', 'lemon']
b = a[:]
print(a)
print(b)
a.append('orange')
b.append('banana')
print(a)
print(b)
'''
输出：['apple', 'pear', 'lemon']
['apple', 'pear', 'lemon']
['apple', 'pear', 'lemon', 'orange']
['apple', 'pear', 'lemon', 'banana']
'''
-------------------------------------------------------
#不使用切片，a,b只是都指向同一个列表
a = ['apple', 'pear', 'lemon']
b = a #list2=list1这种形式无法做到“复制列表”，list2仅仅是一个标签
print(a)
print(b)
a.append('orange')
b.append('banana')
print(a)
print(b)
'''
输出：['apple', 'pear', 'lemon']
['apple', 'pear', 'lemon']
['apple', 'pear', 'lemon', 'orange', 'banana']
['apple', 'pear', 'lemon', 'orange', 'banana']
'''浅拷贝
但是采用切片的方式list1=list2[:]也并非完美无缺。
当列表中的元素为另一个列表时，
也无法实现真正意义上的复制。
仅限于实现了部分复制即为浅拷贝
在Python中进行赋值操作时不可逆。使用切片操作仅能实现浅层复制；而为了确保m对象内部的所有元组与n对象中的元组不相同，则必须执行深拷贝操作。
深拷贝
深拷贝才能保证m内部的元组不同于n内部的元组
from copy import deepcopy
m=[1,2,[3,4],[5,[6,7]]]
n=deepcopy(m)
print(f"m:{m},n:{n}")
n[3][1][0]=-7
print(f"m:{m},n:{n}")
元组Tuple()
不可变（不能修改的值）的列表
用圆括号来标识
不能给元组中的元素赋值
dimensions = (200, 50)
print(dimensions)
#输出：(200, 50)
-------------------------------------------------------
#遍历元组中的所有值
dimensions = (200, 50)
for dimension in dimensions:
print(dimension)
#输出：200
50
-------------------------------------------------------
#修改元组变量：不能修改元组元素，但可以给存储元组的变量赋值
dimensions = (200, 50)
for dimension in dimensions:
print(dimension)
dimensions = (400, 100)
for dimension in dimensions:
print(dimension)
'''
输出：200
50
400
100
'''字典Dictionary{}
一系列的这些信息被整合到一个集合体中
属性名【键】必须是不可变对象：整数，浮点数，字符串，元组
属性值【值】可以是可变对象，也可以是不可变对象。
字典本身是可变的，因此，一个字典可以作为另一个字典的值
1.访问字典中的值
依次指定字典名和放在方括号内的键，返回值是字典中与该键相关的值
#dict[key]
alien = {'color': 'green', 'points': 5}
new_points = alien['points']
print("You just earned "+str(new_points)+"points")
#输出：You just earned 5 points
alien = {'color': 'green', 'points': 5}
print(alien)
alien['x-position'] = 0
alien['y-position'] = 25
print(alien)
'''
输出：{'color': 'green', 'points': 5}
{'color': 'green', 'points': 5, 'x-position': 0, 'y-position': 25}
''' #dict.get(keys,'word') 当字典中有对应key值是返回值，否则，返回‘word’创建空字典
dict={} 是重新创建了一个新字典，而不是将原有的键值对的值改为{}
2.删除键-值对
del 指定字典名和要删除的键
alien = {'color': 'green', 'points': 5}
print(alien)
del alien['points']
print(alien)
'''
输出：{'color': 'green', 'points': 5}
{'color': 'green'}
'''该函数被调用时会移除指定的键及其对应的值。
若未找到该键-值对，则会返回字符串'word'。
dict.clear() 删除字典的所有键值对。
3.由类似对象组成的字典
字典可以存储一个对象的多种信息，也可以存储众多对象的同一种信息
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phli': 'python',
}
print(favorite_languages)
print("Sarah's favorite language is "+favorite_labguages['sarah'].tltle()+" ." )
'''
输出：{'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phli': 'python'}
Sarah's favorite language is C .
'''4.遍历字典
1）遍历所有键-值对
以列表形式，并非真的列表
user_0 = {
'username': 'efermi',
'first': 'enrice',
'last': 'fermi',
}
print(user_0.items())
'''
输出：dict_items([('username', 'efermi'), ('first', 'enrice'), ('last', 'fermi')])
'''遍历字典所有键-值对
user_0 = {
'username': 'efermi',
'first': 'enrice',
'last': 'fermi',
}
for key, value in user_0.items():
print("\nKey: " + key)
print("Value: " + value)
'''
输出：Key: username
Value: efermi
Key: first
Value: enrice
Key: last
Value: fermi
'''2）遍历所有键
- dict.keys()方法返回一个列表，其中包含字典中的所有键。
a = {
'aa': 'a',
'bb': 'b',
'cc': 'c',
}
print(a.keys)
#输出：dict_keys(['aa', 'bb', 'cc'])- 遍历字典所有键
a = {
'aa': 'a',
'bb': 'b',
'cc': 'c',
}
for name in a.keys():
print(name.upper())
'''
输出：AA
BB
CC
'''在字典遍历时，默认会访问所有的键值对。因此即使不调用key()方法也不会影响输出结果的正确性。然而为了提高代码的可读性和可维护性建议显式地调用key()方法这样可以使代码逻辑更加清晰明了
- 按顺序遍历字典中所有键
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phli': 'python'
}
for name in sorted(favorite_languages.keys()):
print(name.title())
'''
输出：Edward
Jen
Phli
Sarah
'''3）遍历所有值
- dict.values()方法，返回一个值列表，不包含任何键
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phli': 'python'
}
print(favorite_languages.values())
#输出：dict_values(['python', 'c', 'ruby', 'python']) favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phli': 'python'
}
print("The following languages have been mentoned:")
for language in favorite_languages.values():
print(language.title())
'''
输出：The following languages have been mentoned:
Python
C
Ruby
Python
'''嵌套
1）将字典存储到列表中
alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 15}
alien_2 = {'color': 'blue', 'points': 5}
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
print(alien)
'''
输出：{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 15}
{'color': 'blue', 'points': 5}
'''2）将列表存储到字典中
favorite_languages = {
'jen': ['python', 'ruby'],
'sarah': ['c'],
'edward': ['ruby', 'go'],
'phil': ['python', 'haskell'],
}
for name, languages in favorite_languages.items():
print("\n" + name.title() + "'s favorite languages are:")
for language in languages:
print("\t" + language.title())3)将字典存储在字典中
users = {
'a':{
'first': 'alert',
'last': 'ein',
'location': 'pri',
},
'b':{
'first': 'mar',
'last': 'cur',
'location': 'paris',
},
}
for username, user_info in users.items():
print("username: " + username)
full_name = user_info['first']+" "+user_info['last']
location = user_info['location']
print("fullname: "+full_name.title())
print("location: "+location.title())
'''输出：
username: a
fullname: Alert Ein
location: Pri
username: b
fullname: Mar Cur
location: Paris
'''集合
集合存储元素，且这些元素不重复。
可用来去重。
s=set{list} s=set{tuple} 可以用列表和元组初始化集合
请注意：允许包含以下类型：整数、浮点数、字符串和元组。不允许包含列表或字典。
if语句
cars = ['audi', 'bwm', 'subaru', 'toyota']
for car in cars:
if car == 'bwm':
print(car.upper())
else:
print(car.title())
#注意冒号冒号冒号！！！
'''条件判断
data1==data2 表示data1和data2的值是否相等
data1 is data2 表示data1和data2是否是同一个对象'''
-----------------------------------------------------
#检查特定值是否包含在列表中：in; not in
cars = ['audi', 'bwm', 'subaru', 'toyota']
if 'bwm' in cars:
print("bwm exists")
if 'sanling' not in cars:
print("sanling not exists")
'''
输出：bwm exists
sanling not exists
'''
---------------------------------------------------
'''检查多个元素：and; or
逻辑连词
cond1 and con2 两个条件都要成立
cond1 or cond2 两个条件成立其一。or语句会先测试第一个条件，如果通过了就不测试第二个条件
'''
ages = [3, 5, 7, 9]
for age in ages:
if age < 8 and age > 6: #可直接写成 if 6 < age < 8:
print ("is", age)
else:
print("not 7")
'''
输出：not 7
not 7
is 7
not 7
'''
----------------------------------------------------
car = 'subaru'
print(car == 'audi')
print(car == 'subaru')
'''
输出：False
True
'''
-----------------------------------------------------
'''
if-elif-else结构
python不要求if-elif结构必须有else代码块，最后的else可以省略。（java中不行，if-else if-else结构最后必须有else）
'''
age = 12
if age < 4:
price = 0
elif age < 18:
price = 5
elif age < 65:
price = 10
else:
price = 5
print("The cost is " + str(price) + ".")
#输出：The cost is 5
----------------------------------------------------
#确定列表不是空的
name = []
if name:
print("Hello "+name+"！")
else:
print("No users")
#输出：No users如果比较时需要忽略大小写
data1.lower()==data2.lower()
如果比较时需要忽略空格
data1.replace(’ ‘,’’)==data2.replace(’ ‘,’’)
如果比较时同时忽略大小写和空格
data1.replace(’ ‘,’’).lower()==data2.replace(’ ‘,’’).lower()
用户输入
number = input("Enter a number, and I'll tell you if it's even or odd: ")
number = int(number)
if number % 2 == 0:
print("\nThe number " + str(number) + " is even.")
else:
print("\nThe number " + str(number) + " is odd.")使用input()函数时可指定提示信息参数；该函数用于获取用户的输入反馈，并将结果以字符串形式返回。
while循环
prompt = "Enter something"
prompt += "\nEnter 'quit' to end the program: "
active = True
while active:
message = input(prompt)
if message == 'quit':
active = False
else:
print(message)函数
1. 定义函数
def greet_user(username):#这里注意冒号
print("Hello, " + username.title() + "!")
greet_user('kate')
'''output: Hello,Kate!'''username 表示函数完成其工作所需的一项信息；'kate’ 表示调用函数时传递给函数的信息
2.传递实参
1）位置实参
要求实参的顺序和形参的顺序相同
def describe_pet(animal_type,pet_name):
'''decribe the information of pet'''
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title())
describe_pet('dog','harry')
'''output: I have a dog.
My dog's name is Harry'''2）关键字实参
每个实参由变量名和值组成
def describe_pet(animal_type,pet_name):
'''decribe the information of pet'''
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title())
describe_pet(animal_type='dog',pet_name='harry')
describe_pet(pet_name='harry',animal_type='dog')
'''output:
I have a dog.
My dog's name is Harry
I have a dog.
My dog's name is Harry'''默认值
每个形参均可设定预设值。当采用预设值时，在参数列表中应首先列出无预设值的参数名后跟其数据类型与初始值，随后依次排列具有预设值的参数名。
def describe_pet(pet_name,animal_type='dog'):
'''decribe the information of pet'''
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title())
describe_pet('harry')
describe_pet(pet_name='harry',animal_type='dog')
'''output:
I have a dog.
My dog's name is Harry
I have a dog.
My dog's name is Harry'''3.返回值
def get_formatted_name(first_name,last_name):
full_name=first_name + " " + last_name
return full_name.title()
musician = get_formatted_name('jimi','hendrix')
print(musician)
'''output: Jimi Hendrix
'''1）可使用默认值让实参变成可选的
给该实参设定一个默认值——空字符串，并将其放置在形参列表的最后位置。然而，在实际操作中，默认参数仅在作为最后一个实参提供时才能与位置参数关联。
def get_formatted_name(first_name,last_name,middle_name=''):
if middle_name:
full_name = first_name + ' ' + middle_name + ' ' + last_name
else:
full_name = first_name + ' ' + last_name
return full_name.title()
musician = get_formatted_name('jimi','hendrix')
print(musician)
musician = get_formatted_name('john','hooker','lee')
'''output: Jimi Hendrix'''2）返回字典
def build_person(first_name,last_name):
person = {'first':first_name,'last':last_name}
return person
musician = build_person('jimi','hendrix')
print(musician)
'''output: {'first': 'jimi', 'last': 'hendrix'} ''' def build_person(first_name,last_name,age=''):
person = {'first':first_name,'last':last_name}
if age:
person['age'] = age
return person
musician = build_person('jimi','hendrix',27)
print(musician)
'''output: {'first': 'jimi', 'last': 'hendrix', 'age': 27}'''4.传递列表
将列表传递给函数后，函数中对这个列表所做的修改都是永久性的。
可向函数传递列表的副本，这样函数的修改只影响副本不影响原件
function_name(list_name[i])5.传递任意数量的实参
def make_pizza(*topping):*topping用于通过python生成一个名为topping的空元组 ，并将其收集到这个元组中。
为了使函数能够接收多种类型的实参，在函数定义时需要将可变数量的参数（如*args）安排在最后的位置。Python首先匹配位置参数和关键字参数，并将所有未被匹配的参数收集到最后一个形式参数中处理。
def build_profiles(first,last,**user_info):通过Python机制初始化为**user_info变量的是一开始为空的字典，并整合接收的所有键-值对。
6. 模块
模块是后缀名为.py的文件
import pizza
from pizza import make_pizza
from pizza import make_pizza as mp
import pizza as p
from pizza import *
类
创建类
class Dog():
def _init_(self,name,age):
'''初始化属性'''
self.name = name
self.age = age
def sit(self):
'''sit'''
print(self.name.title() + “is now sitting.”)Python中，首字母大写的名称指的是类。这个类定义中的括号是空的。
__init__()被视为一种静态初始化方法，在任何情况下当创建对象时会自动运行该方法以完成初始化过程。为了确保不会与默认构造函数产生名称上的混淆，在此类特殊方法中通常会在两端添加两个下划线符号（如__init__()），这种命名约定源自于编程语言设计中的传统规范。参数self作为特殊的传入参数必须存在且位于所有其他可选参数之前使用以避免歧义。
在任何与类相关联的方法调用中，默认会传入参数自（英文自应保持不变）。这使得实例自身成为引用的对象。无需显式地将参数传入。该机制允许实例通过其自身引用来访问类中的属性和方法。
创建实例
my_dog = Dog('willie',6)给属性指定默认值
class Car():
def _init_(self,make,model,year):
'''初始化描述汽车的属性'''
self.make = make
self.model = modle
self.year = year
self.odometer_reading = 0继承
创建子类时，父类必须包含在当前文件中，且位于子类前面。
文件
with open(A) as B
A可以是路径和文件名，也可以只是文件名【这时打开的是当前目录下的A】
返回一个表示文件的对象，仅with代码块内可用
写入
with open(‘test.py’,‘w’) as file_object:
附加到文件
with open(‘test.py’,‘a’) as file_object:
file_object.write("hello")异常
try-except-else