Python零基础入门学习笔记(一)

Python 基础入门学习

一.基本语句

注释： # 单行注释 """ 多行注释 """
print (" ") 输出函数
基本运算符： + - * / // (取整) % (取余) ** (幂运算)
变量的定义： 变量名 = 值 (每个变量使用前都必须赋值，变量在赋值以后才会被创造，定义时不需要指定变量类型)
type( ) 查看变量类型函数
input( ) 变量输入函数用法举例： a = input(“输入数字:”) 输入的任何内容的数据类型默认为字符型str
int(a) float(b) 类型转换函数，将a转换为int型，将b转换为float型
格式化输出 ：

print("格式化字符串" % 变量1)

print("格式化字符串" % (变量1,变量2...))

( %s - 字符串 )

( %d - 带符号十进制整数 ——%06d表示输出六位数，不足地方用0补全)

( %f - 浮点数 ——%.02f表示小数点后显示两位)

( %% - 输出%)
f-格式化字符串 ： print( f’ My name is {name} ' )
转义字符 ： \n 换行 \t 制表符 ： 1个tab键（4个空格）
结束符 ：python中的 print 默认以 \n 为结束符，即默认换行，但可自己设置,如： print('hello', end="\t")
标识符由字母、数字、 下划线 组成， 不能以数字开头 ，不能与关键词重名。标识符区分大小写，命名规则推荐多个单词时全部小写并将每个单词用下划线隔开。

if语句：在Python开发中，Tab和空格一定不能混用！

if 条件1:

    条件1成立时要执行的代码

elif 条件2:
    
    条件2成立时要执行的代码

else:
    
    条件1、2都不成立时执行的代码

if语句训练 ：猜拳游戏

#if-elif-else训练： 猜拳游戏


import random

player = int(input('请出拳 (0-拳头 1-剪刀 2-布):'))
computer = random.randint(0,2)

#平局
if player == computer:
    print('平局')
#电脑胜
elif ( ((player == 0) and (computer == 2)) or ((player == 1)and(computer == 0)) or ((player == 2)and(computer == 1)


    
) ):
    print('电脑赢了！你个睿智！你连电脑都打不过！')
#玩家胜
else:
    print('你赢了！不容易不容易啊！')

随机数 的实现：

导入 random 模块，使用 randint (随机整数) 功如：
```
import random

num = random.randint(0,2) 
```
- 1
- 2
- 3
- 1
- 2
- 3
(num为0、1、2中的随机一个数)

三目运算符：

条件成立时的表达式 if 条件 else 条件不成立时的表达式

如： MaxNum = a if a>b else b

While 循环:

while 条件:

    条件成立时重复执行的代码

注意：计数的初始值习惯写为0

break 和 continue :

break 为 终止循环 ，即不再循环

continue 为退出当前一次循环而直接执行下一次循环，即 跳入下一次循环

for 循环:

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

while 与 else : 如果循环由 break 停止，则else下的代码不执行，for 与 else 的用法与此类似
```
while 条件:

    条件成立时重复执行的代码

else:

    循环正常结束之后执行的代码
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7

二.基本数据类型

字符串可以用单引号、双引号、三引号括起来，字符串为 不可变类型 。
python中每个字符串自带下标和索引，可用 str[x] 来精确访问字符串 str 中的某个字符
切片：指对 字符串 、列表、元组进行截取其中一部分的操作

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

其中切片不包含结束位置下标对应的数据，即开始位置下标和结束位置下标为 [ ) 的包含形式

下标和步长均可不写或写负数，步长默认为1， 若下标开始到结束的方向与步长的方向冲突，则无法选取出数据
字符串的查找： find() 、index() 、count() 、rfind() 、rindex()

find() : 检测某个子串是否包含在这个字符串中，如果存在则返回这个子串开始位置的下标，否则返回-1
```
字符串序列.find( 子串 , 开始位置下标 , 结束位置下标 )
```
- 1
- 1
开始和结束位置下标可以省略，表示在整个字符串序列中查找

index() : 与find()函数的用法一样，但如果不存在要查找的子串，则会报错

count() ：返回某子串在该字符串中出现的次数，若不存在则返回0

rfind() 与 rindex() 查找方向为从右侧开始，其功能与 find() 与 index() 相同
字符串的替换 ： replace() 替换
```
字符串序列.replace ( 旧子串、新子串、替换次数 )
```
- 1
- 1
注意： replace函数并不会改变原有字符串的数据，修改后的数据是replace函数的返回值
字符串的分割 ： split() 分割，返回一个列表，丢失分割字符
```
字符串序列.split(分割字符,分割次数)
```
- 1
- 1
注意：split函数也不会改变原有字符串数据，修改后的数据为函数返回值
列表的合并 ： join() 合并，返回一个 字符串 ，添加连接字符
```
连接字符串.join(多字符串组成的列表)
```
- 1
- 1
注意： join() 合并是 split() 分割的逆序操作
字符串修改大小写函数 ：

capitalize() 将字符串第一个字母转换为大写，其余均为小写

title() 将字符串中每个单词的首字母转化成大写，其余均为小写

lower() 将字符串中的大写全部转换为小写

upper() 将字符串中的小写全部转换为大写

例：

initial: brotheR aNd me
capitalize: Brother and me
title: Brother And Me
lower: brother and me
upper: BROTHER AND ME
字符串删除空白字符函数 ：

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

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

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

例：

initial: " brother and me "
lstrip: “brother and me "
rstrip: " brother and me”
strip: “brother and me”
字符串对齐函数 ： ljust() 、 rjust() 、center()

返回一个原字符串左/右/中对齐，并用指定字符(默认空格)填充至对应长度的新字符串
```
字符串序列.ljust( 长度 , 填充字符 ) 

字符串序列.rjust( 长度 , 填充字符 ) 

字符串序列.center( 长度 , 填充字符 ) 
```
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
例：

initial: brother and me
ljust: brother and me----------------
rjust: ----------------brother and me
center: --------brother and me--------
字符串判断开头或结尾函数 ：

startswith() : 检查字符串是否以指定子串开头，是则返回True，否则返回False。如果设置开始和结束位置下标，则在指定范围内检查
```
字符串序列.startswith(子串，开始位置下标，结束位置下标)
```
- 1
- 1
endswith() : 检查字符串是否以指定子串结尾，用法与 startswith()相同
```
字符串序列.endswith(子串，开始位置下标，结束位置下标)
```
- 1
- 1
字符串字符类型判断函数 ：

isalpha() : 如果字符串非空且只包含字母则返回True , 否则返回False

isdigit() : 如果字符串非空且只包含数字则返回True , 否则返回False

isalnum() : 如果字符串非空且只包含 数字或字母 则返回True, 否则返回False

isspace() : 如果字符串非空且只包含空格则返回True , 否则返回False
列表 : 可以用下标选取指定数据，列表为 可变类型 。
列表数据查找函数 ：

index() : 返回指定数据所在位置的下标，若数据不存在则报错
```
列表序列.index(数据, 开始位置下标, 结束位置下标)
```
- 1
- 1
count() : 返回指定数据在该列表出现的次数，若数据不存在则返回0
```
列表序列.count(数据)
```
- 1
- 1
len() : 返回列表的长度，即列表中数据的个数
```
len(列表序列)
```
- 1
- 1
判断列表中是否存在指定数据 ：

in : 判断指定数据在某个序列的存在，存在返回True，否则返回False
```
'指定数据' in 列表序列
```
- 1
- 1
not in : 与 in 的用法相同，返回结果相反
列表数据增加函数 ：

append() : 列表结尾追加数据，若数据为一个序列，则直接追加 整个序列 到列表的结尾位置
```
列表序列.append(数据)
```
- 1
- 1
extend() : 列表结尾追加数据，若数据为一个序列，则将序列的数据逐一添加到列表，若数据为字符串，则将 单独的每个字符 逐一添加到列表
```
列表序列.extend(数据)
```
- 1
- 1
insert() : 指定位置新增数据，增添方式与 append() 相同
```
列表序列.insert(位置下表,数据)
```
- 1
- 1
列表数据删除函数 ：

del 目标(列表名或列表指定下标数据)

pop() : 删除指定下标的数据(默认为最后一个)，并返回该数据。
```
列表序列.pop(下标)
```
- 1
- 1
remove() : 移除列表中某个数据的第一个匹配项，若匹配失败则报错
```
列表序列.remove(数据)
```
- 1
- 1
clear() : 清空列表中的所有数据
```
列表序列.clear()
```
- 1
- 1
列表数据修改函数 ：

修改指定下标数据 ： 列表序列[下标] = 数据

reverse() : 将列表数据的顺序逆置
```
列表序列.reverse()
```
- 1
- 1
sort() : 对列表的数据进行排序
```
列表序列.sort( key = None, reverse = False)
```
- 1
- 1
注意： reverse = True 降序 reverse = False 升序(默认)
列表数据复制函数 ：

copy() : 列表数据复制
```
新列表序列 = 原列表序列.copy()  
```
- 1
- 1
即将原列表的数据复制到新列表中

列表的循环遍历 ：

while循环方法 :

i = 0

while i < len(list):

    print(list[i])

    i += 1

for循环方法 :

for i in list:

    print(i)

列表嵌套 ：指一个列表里包含了其他的子列表。

例： List = [ ['a' , 'b' , 'c'] , ['1' , '2' , '3'] , ['&' , '$' , '%'] ]

列表综合训练 ：

#将8位老师随机分配到3个办公室中
import random
teacher = ['a1','a2','a3','a4','a5','a6','a7','a8']
room = [[],[],[]]
for i in teacher:
    n = random.randint(0,2)
    room[n].append(i)
print(room)

i = 1
for r in room:
    print(f'办公室{i}的人数是{len(r)},他们分别为：',end = '\t')
    for name in r:
        print(name,end = '\t')
    print()
    i += 1

元组：一个元组可以存储多个数据(与列表相同)，但元组内的数据是不能修改的。

元组名 (数据1 , 数据2 , 数据3)

注意：如果定义的元组只有一个数据，那么需要添加逗号，凑则数据类型为该数据类型，而不是元组(tuple) 数据类型，如 tuple = (‘x’ , )
元组的常见操作 ：

按下标查找数据 ：如tuple1[0] 、 tuple1[1]等

index() : 查找某个数据，用法与字符串、列表的index相同

count() : 统计某个数据在当前元组出现的次数

len() : 统计元组中的数据个数
元组数据的修改 ：

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

如果元组里面有列表，可直接修改列表内的数据，如 (‘abc’ , ‘qwe’ , [‘123’ , ‘456’ , ‘789’] , ‘jkl’) 元组就可以修改其中的 ‘123’ , ‘456’ , ‘789’ 数据
字典：字典里的数据是以 键值对 形式存储的。字典为 可变类型 。

特点：符号为 大括号 ，数据为 键值对 形式出现，各个键值对之间 用逗号隔开 。
```
dict1 = { '键1' : '值1' , '键2' : '值2' , '键3' : '值3' }
```
- 1
- 1
空字典除了可以用空大括号创建，也可以用函数创建: dict2 = dict()
字典常见操作 ：

增 / 改 ： 字典序列[‘key’] = 值

注意：如果key存在则修改该键对应的值，如果key不存在则新增此键值对

删：

del(dict) 删除字典

del dict['Key'] 删除字典中指定键值对

dict.clear() 清空字典

查：

按key值写法直接查找 ： 字典序列[‘键’]

按函数写法查找 ： get() keys() values() items()

get() : 获取某个键对应的值
```
字典序列.get(key , 默认值)
```
- 1
- 1
注意：若当前查找的key不存在则返回默认值，若默认值省略不写则返回None

keys() : 获取字典中所有的key，并返回可迭代对象
```
字典序列.keys()
```
- 1
- 1
values() : 获取字典中所有的values，并返回可迭代对象
```
字典序列.values()
```
- 1
- 1
items() : 获取字典中所有的键值对(key 和 values)，并返回可迭代对象，里面的数据是元组
```
字典序列.items()
```
- 1
- 1

字典的循环遍历 ：

遍历字典的 Key ：

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

遍历字典的 Value ：

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() , 因为使用 {} 会创建空字典。

集合数据特点 ：集合里面的数据会 自动去重 ，不允许重复；集合里面的数据没有顺序，且不支持下标。集合是 可变类型 。
集合的创建 ：

直接创建： s1 = {10 , 20 , 30 , 40 , 50}

使用set()创建： s2 = set('brother')

创建空集合： s3 = set()
集合中数据的常见操作 ：

增加数据 ： add() update()

集合.add(数据) 增加单个数据，要增加的数据在原集合中存在的话，不进行任何操作

集合.update(数据列表) 在集合中增加数据序列

删除数据 ： remove() discard() pop()

集合.remove(数据) 删除集合中的指定数据，如果数据不存在则会报错

集合.discard(数据) 删除集合中的指定数据，如果数据不存在也不会报错

集合.pop() 随即删除集合中的某个数据，并返回这个数据

查找数据 ： in 判断数据在集合序列 not in 判断数据不在集合序列
公共操作 ：运算符、公共方法、容器类型转换

运算符 :

+ 合并，支持字符串、列表、元组

* 复制，支持字符串、列表、元组

in 元素是否存在，支持字符串、列表、元组、字典

not in 元素是否不存在，支持字符串、列表、元组、字典

公共方法 :

len() 计算容器中元素个数

del() 删除元素

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

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

range(start,end,step) 生成从start到end的数字(其中不包含end数字)，步长为step，供for循环使用

enumerate() 将一个可遍历的数据对象(列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中
```
enumerate(可遍历对象, start=0)
```
- 1
- 1
容器类型转换 :

tuple(序列) : 将某个序列转换成元组

list(序列) : 将某个序列转换成列表

set(序列) : 将某个序列转换成集合

推导式(生成式) : 列表推导式、字典推导式、集合推导式

作用：化简代码

列表推导式 ：用一个表达式创建一个有规律的列表或控制一个有规律列表。

创建0-10的列表：

list = [i for i in range(10)]

创建0-10的偶数列表：

list = [i for i in range(10) if i % 2 == 0]

多个for循环列表：

list = [(i , j) for i in range(3) for j in range(3)]

字典推导式 ：快速合并列表为字典或提取字典中目标数据

赋值体验 ：

dict = {i:i*2 for i in range(1,5)}

将两个列表合并为字典 ：

list1 = ['name' , 'age' , 'gender']

list2 = ['Tom' , 20 , 'man']

dict = { list1[i] : list2[i] for i in range(len(list1)) }

提取字典中目标数据 ：

counts = {'a' : 150 , 'b' : 200 , 'c' : 250}

count = {key : value for key , value in counts.items() if value >= 200}

集合推导式 ：

list = [1,1,2]
set = {i * 2 for i in list}