Python学习笔记（一）

学习来源：B站 黑马程序员

注释

1. 单行注释 #
   规范：代码[两个空格]#[空格]注释
2. 多行注释 """ """ 或 ''' '''

数据类型

int，float，bool(True\False)，str(字符串)，list（列表），tuple（元组），set（集合），dict（字典）

格式化输出

age = 18    
name="TOM"
print("年龄:%d" % age)  # 年龄:18
print("姓名:%s 年龄:%d" % (name, age) )  # 姓名:TOM 年龄:18

%06d 占6位，不足以0补全，若超出则原样输出

%.2f 保留两位小数

f 格式化字符串 f “{表达式}” python3.6新增

print(f "姓名：{name} 年龄：{age}") # 姓名：TOM 年龄：18

结束符

print("输出内容"，end="\n")

print("hello", end="\n")  # 默认
print("world", end="\t")
print("hello", end="...")  # 自定义
print("world")

hello
world	hello...world

输入

input("提示信息")

1. 程序执行到input，等待用户输入
2. input接收用户输入后，一般存储到变量
3. 接收到的数据都当做字符串处理

t = input("请输入：")  # 123
print(t)  # 123
print(type(t))  # <class 'str'>

类型转换

int()，float()，str()，list()，tuple()，eval()，，，

eval() 用来计算在字符串中的有效python表达式，并返回一个对象

s1 = "1.1"
print(type(eval(s1)))  # <class 'float'>
s2 = "[1,2,3]"
print(type(eval(s2)))  # <class 'list'>

运算符

算术运算符

+，-、*、/(除)，//(整除)，%，**(指数)，，，

多变量赋值

n1, f1, s1 = 1, 1.1, "hello"
print(n1)  # 1
print(f1)  # 1.1
print(s1)  # hello
a = b = 10  # 多变量赋相同值

逻辑运算符 and or not

18 <= age <=60 Python中可以这样写

三目运算符

a = 1
b = 2
c = a if a > b else b
print(c)  # 2

循环

if

语法

if 条件:
    条件成立执行的代码1
    条件成立执行的代码2
    ......

多重判断

if 条件1:
    条件1成立执行的代码1
    条件1成立执行的代码2
    ......
elif 条件2:
    条件2成立执行的代码1
    条件2成立执行的代码2
    ......
else:
    以上条件都不成立执行的代码
    ......

while

语法

while 条件:
    条件成立执行的代码1
    条件成立执行的代码2
    ......

while...else

while 条件:
    条件成立重复执行的代码
else:
    循环正常结束之后要执行的代码

else是循环正常结束之后要执行的代码，在continue控制下可以正常执行

for

语法

for 临时变量 in 序列:
    重复执行的代码1
    重复执行的代码2
    ......

s1 = "hello"
for i in s1:
    print(i)

输出
h
e
l
l
o

for...else

for 临时变量 in 序列:
    重复执行的代码
    ...
else:
    循环正常结束之后要执行的代码

字符串

a = "hello" \
    "world"
print(a)

b = """hello
world"""
print(b)

c = 'I\'am TOM'  # 转义 \'
print(c)

输出
helloworld
hello
world
I'am TOM

切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

语法：

序列[开始位置下标 : 结束位置下标 : 步长]

注意：

1. 不包含结束位置下标对应的数据，正负整数均可
2. 步长是选取间隔，正负整数均可，默认步长为1。

str1 = "0123456789"
print(str1[2:5:1])  # 234
print(str1[2:5:2])  # 24
print(str1[2:5])  # 234
print(str1[2:])  # 23456789
print(str1[:5])  # 01234
print(str1[:])  # 0123456789
print(str1[::-1])  # 9876543210   如果步长为负数，表示倒叙选取
print(str1[-4:-1])  # 678   下标-1表示最后一个数据，依次向前类推
print(str1[-4:-1:-1])  # 不能选取出数据：-4到-1，选取方向为从左到右，但是-1步长，从右到左选取
# 如果选取方向（下标开始到结束的方向）和 步长的方向冲突，则无法选取
print(str1[-1:-4:-1])  # 987

查找

1. find() 返回子串第一次出现的位置，没有则返回-1 字符串序列.find(子串，开始位置下标，结束位置下标)
2. rfind() 和find()功能相同，但查找方向为从右侧开始
3. rindex() 和rindex()功能相同，但查找方向为从右侧开始
4. index() 检测某个子串是否包含于这个字符串中，有则返回开始位置下标，否则报错 字符串序列.index(子串，开始位置下标，结束位置下标)
5. count() 返回子串出现的次数 字符串序列.count(子串，开始位置下标，结束位置下标)

修改

1. replace() 替换 字符串序列.replace(旧子串，新子串，替换次数)

2. split() 按照指定字符分割字符串 字符串序列.split(分割字符，num) num表示分割字符出现的次数，即 将来返回数据个数为num+1个 分割会丢失分割字符

3. join() 用一个字符或字符串合并字符串，即是将多个字符串合并为一个新的字符串 字符或子串.join(多字符串组成的序列)

   l1 = ["a", "b", "c"]
   str2 = "...".join(l1)
   print(str2)  # a...b...c
   

4. capitalize() 将字符串第一个字符转换成大写

5. title() 将字符串每个单词首字母转换成大写

6. lower() 将字符串中大写转小写

7. upper() 将字符串中小写转大写

8. lstrip() 删除字符串左侧空白字符

9. rstrip() 删除字符串右侧空白字符

10. strip() 删除字符串两侧空白字符

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

    str1 = "hello"
    print(str1.ljust(10, "."))  # hello.....
    

12. rjust() 右对齐

13. center() 居中

判断

1. startswith() 检查字符串是否以指定子串开头，是则返回True，否则返回False。 字符串序列.startswith(子串，开始位置下标，结束位置下标)
2. endswith() 是否以指定子串结尾
3. isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回True，否则返回False
4. isdigit() 如果字符串只包含数字则返回True，否则返回False
5. isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False
6. isspace() 如果字符串中只包含空白，则返回True，否则返回False

列表

格式

[数据1，数据2，数据3，数据4......]

列表可以一次性存储多个数据，且可以为不同数据类型

常用操作

查找

1. 下标

   name_list = ["Tom", "Jerry", "Rose"]
   print(name_list[0])  # Tom
   print(name_list[1])  # Jerry
   print(name_list[2])  # Rose
   

2. 函数

   1. index() 返回指定数据所在位置的下标

      name_list = ["Tom", "Jerry", "Rose"]  
      print(name_list.index("Rose", 0, 3))  # 2  区间左闭右开
      

   2. count() 统计指定数据在当前列表中出现的次数

   3. len() 列表长度，即列表中数据的个数

判断是否存在

in 判断指定数据在某个列表序列，如果在返回True，否则返回False

name_list = ["Tom", "Jerry", "Rose"]
print("Jerry" in name_list)  # True
print("Jerrys" in name_list)  # False

not in 判断指定数据不在某个列表序列，如果不在返回True，否则返回False

增加

1. append() 列表结尾追加数据

2. extend() 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表

   name_list = ["Tom", "Jerry", "Rose"]
   name_list.extend("Jack")
   print(name_list)  # ['Tom', 'Jerry', 'Rose', 'J', 'a', 'c', 'k']
   
   name_list = ["Tom", "Jerry", "Rose"]
   name_list.extend(["Jack", "xiaoming"])
   print(name_list)  # ['Tom', 'Jerry', 'Rose', 'Jack', 'xiaoming']
   

3. insert() 指定位置新增数据

   name_list = ["Tom", "Jerry", "Rose"]
   name_list.insert(3, "Jack")
   print(name_list)  # ['Tom', 'Jerry', 'Rose', 'Jack']
   

删除

1. del

   # 删除列表
   name_list = ["Tom", "Jerry", "Rose"]
   del name_list
   print(name_list)  # NameError: name 'name_list' is not defined
   # 删除数据
   name_list = ["Tom", "Jerry", "Rose"]
   del name_list[1]
   print(name_list)  # ['Tom', 'Rose']
   

2. pop() 删除指定下标的数据（默认为最后一个），并返回该数据

   name_list = ["Tom", "Jerry", "Rose"]
   del_name = name_list.pop(1)
   print(del_name)  # Jerry
   print(name_list)  # ['Tom', 'Rose']
   

3. remove() 移除列表中某个数据的第一个匹配项

   name_list = ["Tom", "Jerry", "Rose"]
   name_list.remove("Jerry")
   print(name_list)  # ['Tom', 'Rose']
   

4. clear() 清空列表

修改

1. reverse() 逆置

2. sort() 排序

   列表序列.sort(key = None, reverse = False)
   reverse=True 降序  reverse=False 升序（默认）
   
   l1 = [3, 5, 1, 2, 4]
   l1.sort()
   print(l1)  # [1, 2, 3, 4, 5]
   l1.sort(reverse=True)
   print(l1)  # [5, 4, 3, 2, 1]
   

复制

copy()

name_list = ["Tom", "Jerry", "Rose"]
name_list2 = name_list.copy()
print(name_list2)  # ['Tom', 'Jerry', 'Rose']

列表嵌套

name_list = [["小明", "小红", "小黑"], ["Tom", "Jerry", "Rose"], ["1", "2", "3"]]
print(name_list[1][1])  # Jerry

元组

一个元组可以存储多个数据，元组内的数据是不能修改的

定义

t1 = (10, 20, 30)  # 多个数据元组
t2 = (10,)  # 单个数据元组

常用操作

查找

1. 下标
2. index()
3. count()
4. len()

修改

元组内的直接数据如果修改则立即报错

但是如果元组里面有列表，修改列表里面的数据则是支持的

t1 = (10, 20, ["a", "b", "c"])
print(t1)  # (10, 20, ['a', 'b', 'c'])
t1[2][0] = "A"
print(t1)  # (10, 20, ['A', 'b', 'c'])

字典

字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。

创建

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
dict2 = {}
dict3 = dict()

常用操作

修改

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
dict1["name"] = "Jerry"
print(dict1)  # {'name': 'Jerry', 'age': 20, 'gender': '男'}
dict1["id"] = "001"
print(dict1)  # {'name': 'Jerry', 'age': 20, 'gender': '男', 'id': '001'}

删除

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
del dict1["gender"]
print(dict1)  # {'name': 'TOM', 'age': 20}

dict1.clear()  # 清空
print(dict1)  # {}

del(dict1)   # 删除字典

查找

1.get() 字典序列.get(key, 默认值)

如果key不存在则返回第二个参数，默认为None

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
print(dict1.get("name"))  # TOM
print(dict1.get("id", 999))  # 999 
print(dict1.get("id"))  # None

2.keys()

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
print(dict1.keys())  # dict_keys(['name', 'age', 'gender'])

3.values()

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
print(dict1.values())  # dict_values(['TOM', 20, '男'])

4.items()

dict1 = {"name": "TOM", "age": 20, "gender": "男"}
print(dict1.items())  # dict_items([('name', 'TOM'), ('age', 20), ('gender', '男')])  返回可迭代对象，内部是元组

遍历

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

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

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

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

集合

创建

使用{}或set()，如果创建空集合，只能用set()创建，因为使用{}会创建空字典

set1 = {10, 10, 20, 30}  # {10, 20, 30}
set2 = set("abcdef")  # {'c', 'a', 'b', 'f', 'e', 'd'} 
set3 = set()  # set()

常用操作

增加

1. add() s1.add(10)
2. update() s1.update([10,20])

删除

1. remove() s1.remove(10) 数据不存在则报错
2. discard() s1.discard(10) 数据不存在不报错
3. pop() del_num = s1.pop() 随机删除某个数据，并返回这个数据

查找

1. in：判断数据在集合序列

2. not in ：判断数据不在集合序列

   set1 = {10, 20, 30}
   print(10 in set1)  # True
   print(10 not in set1)  # False
   

公共操作

运算符

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

方法

1. len() 计算容器元素个数

2. del或del() 删除

3. max() 返回容器中元素最大值

4. min() 返回容器中元素最小值

5. range(start, end, step) 生成从start到end的数字，步长为step，供for循环使用

6. enumerate() 将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中

   enumerate(可遍历对象，start = 0)   start为遍历下标的起始值
   list1 = ["abc", "acb"]
   for i in enumerate(list1):
       print(i)
   
   for index, char in enumerate(list1, start=1):
       print(f"下标是{index}，对应的字符是{char}")
   

容器类型转换

1. tuple() 将某个序列转换成元组
2. list() 将某个序列转换成列表
3. set() 将某个序列转换成集合

推导式

一、列表推导式

list1 = [i for i in range(10)]
print(list1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list1 = [i for i in range(0, 10, 2)]
print(list1)  # [0, 2, 4, 6, 8]

list1 = [i for i in range(10) if i % 2 == 0]
print(list1)  # [0, 2, 4, 6, 8]

list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)  # [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

二、字典推导式

dict1 = {i: i**2 for i in range(1, 5)}
print(dict1)  # {1: 1, 2: 4, 3: 9, 4: 16}

# 将两个列表合并为一个字典
list1 = ["name", "age", "gender"]
list2 = ["Tom", 20, "man"]
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)  # {'name': 'Tom', 'age': 20, 'gender': 'man'}

# 提取字典中目标数据
counts = {"MBP": 268, "HP": 125, "DELL": 201, "Lenovo": 199, "acer": 99}
# 提取电脑数量大于等于200的字典数据
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1)  # {'MBP': 268, 'DELL': 201}

三、集合推导式

list1 = [1, 1, 2]
set1 = {i**2 for i in list1}
print(set1)  # {1, 4}