python简单教程————————持续更新

这是去年看书自学python时写下的笔记，现在还在整理，有些地方也在修改，持续更新中
参考书籍《Python基础教程（第3版》——Magnus Lie Hetland 《Python编程从入门到实践》——Eric Matthes

一、读取键盘输入

• python中使用input()函数读取一行
• input()接收一个python表达式作为输入，并将其返回

input('请输入：')

• 赋值输入

name = input('请输入您的姓名：')
print("您的名字是：",name)

• 注意：input函数接收的只是字符串

a = input("请输入数字：")
b = input("请输入数字：")
print("a+b = ",a+b)

• 接收数字：使用强制转换即可

a = int(input("请输入数字："))
b = int(input("请输入数字："))
print("a+b = ",a+b)

• 如果要像下列C语言中代码一样把%d与i联系起来

int i = 1;
printf("%d\n",i);

a = int(input("请输入数字："))
b = int(input("请输入数字："))
print("正确输出格式",'%d + %d = %d' % (a, b, a + b))# 注意百分号
print("错误输出格式",'%d + %d = %d' , (a, b, a + b))

二、序列及其序列通用操作

• 序列是一种数据结构

• 其中的元素带有编号

• 列表、字符串和元组都是序列

• 列表可以修改内容，字符串和元组不可以修改

  1、索引

• 指定编号,第一个元素编号是0，第二个元素编号是1，以此类推

x = 'Hello' 
print(x[0])
------------------
print('Hello'[0])
这两个结果一样

2、切片

• 访问特定范围内的元素,设置起点索引和终点索引，提取元素时从起点索引指定元素开始提取，不包含终点索引指定元素

x = 'Hello world!'
print(x[0:12])

（1）指定起始索引和终止索引：

列表名 = ['a','b','c','d','e']
print(列表名[1:4])
'''1和4为列表索引，列表名[1:4]指的是取
列表名[1]，列表名[2]，列表名[3]
即，['b','c','d']这三个元素
'''

List = ['a','b','c','d','e']
print(List[1:4])

（2）若不指定第一个索引：

列表名 = ['a','b','c','d','e']
print(列表名[:4])
'''
python从列表开头提取元素
['a','b','c','d']
'''

List = ['a','b','c','d','e']
print(List[:4])

（3）若不指定终止索引：

列表名 = ['a','b','c','d','e']
print(列表名[1:])
'''
由于起始索引是1，python会从列表第二个元素‘b’开始提取至最后一个元素
['b','c','d','e']
'''            

List = ['a','b','c','d','e']
print(List[1:])

（4）利用负数索引提取列表元素：

列表名 = ['a','b','c','d','e']
print(列表名[-3:])
'''输出列表中最后三个元素:
['c', 'd', 'e']
 注意：
若负数索引放在切片表达式 列表名[:-n] 冒号的后面，则表明去掉列表中最后的几个元素元素
            列表名[:-1] 去掉最后一个元素
            列表名[:-2] 去掉最后两个元素
            列表名[:-3] 去掉最后三个元素
            以此类推
'''

List = ['a','b','c','d','e']
print(List[-3:])

List = ['a','b','c','d','e']
print(List[:-3])

（5）指定步长

'''
列表[起点索引:终点索引:n]
*步长为n，从起点到终点每隔n-1个位置提取相应元素
'''
x = [1,2,3,4,5,6,7,8,9,10]
print(x[0:10:2])
'''结果	[1,3,5,7,9]'''

x = [1,2,3,4,5,6,7,8,9,10]
print(x[0:10:2])

​

'''
*步长为负数时，从右向左提取元素
第一个索引必须比第二个索引大
'''
x = [1,2,3,4,5,6,7,8,9,10]
print(x[10:0:-2])
# 结果	[10,8,6,4,2]
print(x[0:10:-2])
# 结果	[]
# 省略第一个索引，则从列表最后一个元素开始从右向左遍历
print(x[:5:-2])
# 结果	[10,8]

3、序列相加

• 用加法拼接序列,只能拼接同类型的序列

print([1,2,3]+[4,5,6])
# [1,2,3,4,5,6]

4、乘法

• 序列与数n相乘，重复这个序列n次创建一个新的序列

print([32]*4)
# [32,32,32,32]

None、空列表和初始化
x = [None]*10
print(x)
# [None, None, None, None, None, None, None, None, None, None]

5、成员资格

（1）用 in 判断特定值是否包含在列表中

List = ['No1','No2','No3','No4']
print('No1' in List)
print('No5' in List)

（2）用 not in 确定特定值不包含在列表中

List = ['No1','No2','No3','No4']
number = 'No5'
if number not in List:
    print(number + "不在列表中")

6、长度、最大值、最小值、和

x = [1,2,3,4,5,6,7,8,9,10]
print(min(x))
# 1
print(max(x))
# 10
print(sum(X))
# 55
print(len(x))
# 10

三、列表

• 语法：列表名 = []

1、函数list()

• 函数list()，括号里只能填入字符串，并将每个字符放入列表输出

list('Hello')
# ['H','e','l','l','o']

2、基本的列表操作

(1)修改列表，给元素赋值

列表名[] = 'xxx' # 直接将列表中指定位置的某个元素替换修改

x = [1,1,1]
x[1] = 2
print(x)

(2)删除元素

• 删除任意位置元素：del 列表名[]

x = [1,1,1]
del x[1]
print(x)
# [1,1]

(3)给切片赋值

• 指定起始索引，省略终点索引，替换起始索引(包含起始索引指定元素)以后的所有元素

x = [1,1,1,1,1]
x[2:] = [3,3,3,3,3]
print(x)
#[1,1,3,3,3,3,3]

• 省略起始索引，指定终点索引，替换终点索引(不包含终点索引指定元素)以前的所有元素

x = [1,1,1,1,1]
x[:2] = [3,3,3,3,3]
print(x)

• 起始索引与终点索引相同，插入新元素

x = [1,1,1,1,1]
x[2:2] = [3,3,3,3,3]
print(x)

• 指定范围，插入空列表删除元素

x = [1,1,1,1,1]
x[1:3] = [] # 等效于 del x[1:3]
print(x)

3、列表方法

(1)、append( )

• 列表末尾添加元素：列表名.append(‘xxx’)

x = [1,2,3]
x.append(4)
print(x)

(2)、clear( )

• 清空列表内容

x = [1,2,3]
x.clear()
print(x)

(3)、copy( )

• 复制列表副本

x = [1,2,3]
y = x.copy()
y[2] = 4
print(y)
print(x)

(4)、count( )

• 计算指定元素在列表中出现的次数

x = [1,2,3,1,1,1,1]
print(x.count(1))

(5)、extend( )

• 同时将多个值添加到列表末尾，用一个列表来扩展另一个列表
• 将列表y添加给列表x，则x被永久修改

x = [1,2,3]
y = [4,5,6]
x.extend(y)
print(x)

• 常规拼接，用加号，使两个列表相加，这时开辟一个新的内存用于存放两个列表相加后的值，原列表不被修改

x = [1,2,3]
y = [4,5,6]
print(x+y)
print(x)
print(y)

(6)、index( )

• 在列表中查找指定值第一次出现的索引

x = [1,2,3,1,2,1]
print(x.index(1))

(7)、insert( )

• 列表任意位置插入或添加新元素

x = [1,2,3]
x.insert(3,4)
print(x)
x.insert(3,'awsl')
print(x)

(8)、pop( )

• pop()弹出栈顶元素：列表名.pop()
• 弹出任意位置元素：列表名.pop(位置)
• pop是唯一一个既修改又返回一个非None值的列表方法

x = [1,2,3]
print(x.pop())
print(x)
print(x.pop(0))
print(x)

(9)、remove( )

• 删除第一个为指定对象的值

x = [1,2,3,1]
x.remove(1)
print(x)

(10)、reverse( )

• 按相反顺序排列列表中的元素

x = [1,2,3,4,5]
x.reverse()
print(x)

(11)、sort( )

• 对列表里的字符按从小到大的顺序排列，字符串按字母顺序排列

x = [2,4,5,6,3,1]
x.sort()
print(x)
y = ['asd','cse','bfhg','awsl']
y.sort()
print(y)

(12)、高级排序

• 方法sort接受两个可选参数：key和reverse

y = ['asd','csecd','bfhgsw','awsl']
y.sort(key=len)	# 根据长度对元素进行排列
print(y)

• 列表名.sort(reverse=True)永久修改，先按字母表顺序排列，再倒序排列，真值True必须首字母大写

x = [2,4,5,6,3,1]
x.sort(reverse = True)
print(x)

四、元组

• 元组名 = (‘a’,‘b’,‘c’)
• 元组类似于列表，用圆括号标识，其变量不可修改，只能重新定义
• 元组名[0] = ‘s’ 报错，不能修改 除非 元组名 = (‘s’,‘b’,‘c’) 重新定义

# 创建一个值的元组
x = (42,)
print(x)

五、字符串

1、center( )

• 通过在两边添加填充字符(默认为空格)让字符串居中

print("Hello World!".center(39))
print("Hello World!".center(39,"*"))

2、find( )

• 在字符串中查找子串，如果找到，就返回字串的第一个字符的索引，否则返回-1

print("Hello World! Hello Python!".find('World'))

• find返回的并非布尔值，如果返回0，则表示它在索引0处找到了指定的字符串

# 指定搜索起点和终点
sub = "$$$ get rich now!!! $$$"
print(sub.find('!!!',1,21))

3、join( )

• 将序列中的元素以指定的字符连接生成一个新的字符串

q = ['1','2','3','4','5']
p = '+'
print(p.join(q))

4、lower( )

• 返回字符串的小写版本

print("HELLO WORLD!".lower())

5、title( )

• 将字符串首字母转换为大写

print("hello world!".title())

6、replace( )

• 将指定的字串替换为另一个字符串，并返回替换后的结果

print("Hello World!".replace('World','Python'))

7、split( )

• 将字符串相同的字符作为分隔符，把字符串拆分成序列

print('1+2+3+4+5'.split('+'))# 把‘+’号作为分隔符
print("Hello World".split())# 把空格符作为分隔符

8、strip( )

• 将字符串开头和末尾的空白删除，但不包含中间的空白

print('     	Hello Python !	     '.strip())

• 指定删除字符

print('***	Hello * Python !*	world!***'.strip('world * !'))

因为strip只删除开头或末尾的指定字符，因此中间的星号未被删除

9、translate( )

• 替换字符串特定部分，但只能进行单字符的替换，优点在于能同时替换多个字符，效率比replace高，使用translate前必须创建一个转换表

table = str.maketrans('s','w')
print('Awsl'.translate(table))

10、判断字符串是否满足特定的条件

• 很多字符串方法以is大头，如isspace、isdigit和isupper，它们判断字符串是否具有特定的性质
  如果符合则返回True，否则返回False

五、字典

1、什么是字典

• 映射：通过名称来访问其各个值的数据结构
• 字典：python内置映射类型，其中的值不按顺序排列，存储在键下。
• 键-值对，每一个键与一个值相关联
• 用花括号表示,键和值之间用冒号分开，每一对键—值用逗号隔开
• 键可以是数、字符串或元组
• 注意：字典中键-值对排序不确定

# 字典名 = {键:值,键:值...}
user = {
     'name':'LinY','id':123456}

2、访问字典中的值

• 指定字典名和放在方括号内的键

# 字典名[键名]
user = {
     'name':'LinY','id':123456}
print('name：',user['name'])

3、添加键-值对

• 指定字典名、用方括号括起来的键和相关联的值

# 字典名[键名] = 值
user = {
     }
print("这里面是空的：",user)
user['name'] = 'LinY'
print('user = ',user)

4、修改字典中的值

• 指定字典名、用方括号括起来的键和相关联的”新“值

# 字典名[键名] = "新"值
user = {
     'name': 'Auto', 'id': 123456}
print('user = ', user)
user['name'] = 'Ato_Uo'
print('user = ', user)

5、删除键-值对

• 用del语句将字典中的键-值对彻底删除

# del 字典名[键名]
user = {
     'name': 'Auto', 'id': 123456}
print('user = ', user)
del user['name']
print('user = ', user)

6、遍历字典

(1)遍历所有的键-值对

• 用for循环，声明两个变量（名称随意），依次存储键-值对中的键和值
• 声明的两个变量，第一个变量放健，第二个变量放对应的值

user = {
     
    'username': 'LinY',
    'address': 'Location'
}
for key, value in user.items():
    print("\nKey: " + key)
    print("Value: " + value)

(2)遍历所有的键

• 使用方法keys()
• 字典名.keys()

user = {
     
    'username': 'LinY',
    'address': 'Location'
}
for k in user.keys():
    print(k.title())
print('\n')
for k in user:
    print(k.title())
'''
“遍历字典”时会默认遍历所有的键
所以  for k in user.keys():
可以写成 for k in user:
但是直接打印字典中的键时 print(user_0.keys()) 这时，keys()不能省略
'''

(3)遍历字典中所有的值

• 使用方法values()
• 字典名.values()

user = {
     
    'username': 'LinY',
    'address': 'Location'
}
for v in user.values():
    print(v)

7、嵌套

• 将字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套

(1)在列表中存储字典

ball_0 = {
     'color': 'green', 'volume': 10}
ball_1 = {
     'color': 'yellow', 'volume': 10}
ball_2 = {
     'color': 'red', 'volume': 10}
balls = [ball_0, ball_1, ball_2]
for ball in balls:
    print(ball)

(2)在字典中存储列表

ball = {
     
    'colors': ['yellow', 'red', 'blue']
}
for color in ball['colors']:
    print(color)

(3)在字典中存储字典

users = {
     
    'LinY': {
     
        'id': 123456,
        'location': 'beijing'
    },
    'Asail': {
     
        'id': 987654,
        'location': 'shanghai'
    }
}
print(users.keys())
print(users.values())
for user_name, user_info in users.items():
    print("\nUser_name: " + user_name)
    location = user_info['location']
    print('Loction:' + location.title())

8、字典方法

1、clear

• 删除所有的字典项，就地执行，不返回值

users = {
     
    'LinY': {
     
        'id': 123456,
        'location': 'beijing'
    },
    'Asail': {
     
        'id': 987654,
        'location': 'shanghai'
    }
}
print(users)
users.clear()
print(users)

2、copy

• 返回一个新的字典，包含与原来字典中相同的键-值对
• 但是copy是浅复制，值本身是原件，而非副本，
• 替换副本中的值，原件不受影响，
• 而修改副本中的值，原件也将发生变化，因为原件的指向也是被修改的值

users_info = {
     'name': 'LinY', 'loves': ['game', 'music', 'reading']}
users_copy = users_info.copy()
print("users_info = ", users_info)
print("users_copy = ", users_copy)
print("users_copy == users_info ：", users_copy == users_info)
print("users_copy.keys() 内存地址：", id(users_copy.keys()))
print("users_info.keys() 内存地址：", id(users_info.keys()))
print("users_copy.values() 内存地址：", id(users_copy.values()))
print("users_info.values() 内存地址：", id(users_info.values()))
print("==============================================================")
users_copy['loves'].remove('reading')
print("users_copy['loves'].remove('reading')")
print("users_info = ", users_info)
print("users_copy = ", users_copy)
print("users_copy == users_info ：", users_copy == users_info)
print("users_copy.keys() 内存地址：", id(users_copy.keys()))
print("users_info.keys() 内存地址：", id(users_info.keys()))
print("users_copy.values() 内存地址：", id(users_copy.values()))
print("users_info.values() 内存地址：", id(users_info.values()))

print("==============================================================")

users_copy['loves'] = 'game'
print("users_copy['loves'] = 'game'")
print("users_info = ", users_info)
print("users_copy = ", users_copy)
print("users_copy == users_info ：", users_copy == users_info)
print("users_copy.keys() 内存地址：", id(users_copy.keys()))
print("users_info.keys() 内存地址：", id(users_info.keys()))
print("users_copy.values() 内存地址：", id(users_copy.values()))
print("users_info.values() 内存地址：", id(users_info.values()))

print("==============================================================")
'''
如果直接使用remove()函数users_copy['loves'].remove('reading')进行修改,输出的值一样，副本修改，原件也修改
用等号users_copy['loves'] = 'game'直接替换健对应的值，输出时和原件的值不一样，
但奇怪的是，用print(id(users_copy.values()))和print(id(users_info.values()))查看两者的内存地址却是相同的
建议避免使用copy()函数使用deepcopy()函数
'''

• 注意：
  如果直接使用remove()函数users_copy[‘loves’].remove(‘reading’)进行修改,输出的值一样，副本修改，原件也修改
  用等号users_copy[‘loves’] = 'game’直接替换健对应的值，输出时和原件的值不一样，
  但奇怪的是，用print(id(users_copy.values()))和print(id(users_info.values()))查看两者的内存地址却是相同的
  建议避免使用copy()函数使用deepcopy()函数

• 深复制使用模块copy中的函数deepcopy，同时复制值及其包含的所有值

3、fromkeys

• 创建一个新字典，其中包含指定的键，且每个键对应的值都是None

4、get

• 使用get来访问字典中的键，查找相对应的值
• 如果访问的键不存在，则返回None

• 与setdefault不同，指定的键不存在时，不能在字典中添加键-值对

5、items

• 返回一个包含所有字典项的列表，其中每个元素都是为(key，value)的形式
• 返回值属于一种名为字典视图的特殊类型

6、keys

• 方法keys返回一个字典视图，包含指定字典中的键

7、pop

• 用于获取与指定键相关联的值，并将该键-值对从字典中删除

8、popitem

• 随机弹出一个字典项，因为字典项的顺序是不确定的，没有最后一个元素的概念

9、setdefault

• 获取与指定键相关联的值，还能再字典不含指定值的时候，添加指定的键-值对

10、update

• 用一个字典来更新另一个字典
• 对于通过参数提供的字典，将其项添加到当前字典中
• 如果当前字典包含的键相同的项，就替换掉它

11、values

• 返回一个又字典中的值组成的字典视图，不同于keys，values返回的视图包含重复的值