python学习笔记01（基础）

00，python中常用的内置函数

0.1，input函数

-input函数：该函数用来获取用户的输入

• 注意：input函数的返回值是一个字符串
• input()函数中可以设置一个字符串作为提示参数
• 可以使用type内置函数查看返回值类型

username=input('请输入你的名字：')
objectType=type(username)
print(objectType)
print(username)

0.2，range函数

• range()：用来生成一个自然数的序列
• 参数：
  起始位置（可以省略，默认为0）
  结束位置
  步长（可以省略，默认为1）

# 生成并打印自然序列
for i in range(10):
    print(i)
运行结果：
0 1 2 3 4 5 6 7 8 9

01，概述

1.1，什么是计算机语言？

• 计算机就是一台用来计算机的机器，需要通过计算机的语言来控制计算机，计算机语言也就是我们常说的编程语言。

1.2，计算机语言发展的三个阶段

• 机器语言
• 符号语言（汇编）
• 高级语言（C，C++，Java，Python等）

1.3，编译型语言和解释性语言的区别

• 编译型语言：例如，C语言
  编译型语言，会在代码执行前将代码编译为机器码，然后将机器码交由计算机执行
  a(源码) --编译–> b(编译后的机器码)
  特点：执行速度特别快， 跨平台性比较差

• 解释型语言 ：例如，Python ，Java
  解释型语言，不会在执行前对代码进行编译，而是在执行的同时一边执行一边编译
  a（源码）–解释器–> 解释执行
  特点：执行速度比较慢，跨平台性比较好

02，流程控制语句

• 注意：python语句中不可随意缩进

2.1，条件判断语句（if）

• 条件判断语句：if
• 语法：if条件表达式:语句
• 默认情况下，if语句会执行紧随其后的那条语句，如果希望if语句控制多条语句，就要使用代码块（缩进同一的语句为同一代码块）。

第一种：if语句会执行紧随其后的那条语句
i=0;
if i<6:print(i)

第二种：使用代码块（通过缩进）
i=0
if i<6:
    print(i)
    print(i+1)
    print(i+2)

• 在if语句中可以使用逻辑运算符来连接多个条件
  逻辑运算符：() > not > and > or
  关系运算符：<，>，==,!=

num =8
if 10<num<20:
    print('num比10大比20小')
if num>10 and num<20:
    print('num比10大比20小')
if num<10 or num>20:
    print('num小于10或者大于20')

• 条件判断语句：if-else

age=input('请输入你的年龄：')
# 强制类型转换
age=int(age)
if age>=18:
    print('你已经成年了，，，')
else:
    print('你还未成年，，，，')

• 条件判断语句：if-elif-...-else

score=input('请输入你的成绩0——100：')
# 强制类型转换
score=int(score)
if 0<=score and score<60:
    print('你的成绩为：不及格')
elif 60 <= score < 70:
    print('你的成绩为：差')
elif 70 <= score < 80:
    print('你的成绩为：中')
elif 80 <= score < 90:
    print('你的成绩为：良')
elif 90 <= score < 100:
    print('你的成绩为：优')
else:
    print('你输入的成绩不符合要求，，，，')

2.2，循环语句（while）

• 循环语句分为两种：while和for
• while循环：
• 语法：

while 条件表达式:
	代码块

• 执行流程：先判断条件表达为真则继续执行

i=3
while i>0:
    print(i)
    i-=1

运行结果：3  2	1

2.3，break和continue关键字

• break和continue关键字只会对最近的循环起作用
• break：跳出循环（结束整个循环）
• continue：结束当前循环

03，python中的序列

3.1，序列（sequence）

3.1.1，序列的概述

• 序列是Python中最基本的一种数据结构
• 数据结构指计算机中数据存储的方式
• 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引
• 序列的分类：
  可变序列（序列中的元素可以改变）：列表（list）
  不可变序列（序列中的元素不能改变）：字符串（str），元组（tuple）

3.1.2，切片

• 切片：从现有的列表中获取一个子列表
  语法：列表[起始：结束]
  注意：
  通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素。
  做切片操作时会返回一个新的列表，但是不会影响原来的列表
  省略起始位置，会从头开始截取
  省略结束位置，会截取到最后
  起始位置索引和结束位置索引都可以不写，相当于创建了一个列表的副本
  如果结束索引为负数，则截取到倒数此数的前一个元素

my_list=[1,2,3,4,5]
# 使用len()函数获取列表的长度，获取到的长度值为列表的最大索引+1
print(len(my_list)) # 列表长度5
print(my_list[0:3]) # [1, 2, 3]
print(my_list[:3]) # 省略起始位置 [1, 2, 3]
print(my_list[0:]) # 省略结束位置 [1, 2, 3, 4, 5]
print(my_list[:])  # 全部省略 [1, 2, 3, 4, 5]
print(my_list[:-1]) # 结束索引为负数 [1, 2, 3, 4]

• 步长：指定步长间隔截取列表中元素
  语法：列表[起始:结束:步长]
  注意：步长不能为0，但可以为负数，如果为负数则是从后面倒着往前取值

• 通过切片来修改列表：在给切片赋值时只能使用序列
  my_list[0:0]=['AISMALL01','AISMALL02']：从列表的前面插入元素
  my_list[0:2]=['AISMALL01','AISMALL02']：使用新元素替换就旧元素，两个替换两个
  my_list[0:2]=['AISMALL01','AISMALL02','AISNALL03']：使用新元素替换就旧元素，三个替换两个
  也就是说使用切片替换元素的时候个数可以不匹配
  当切片中设置步长的时候，序列中的元素的个数必须和切片中元素的个数一致，否则报错

# 创建一个列表
my_list=['aismall01','aismall02','aismall03','aismall04']
# 打印修改前的序列
print("修改前：",my_list)
# 通过索引修改元素
my_list[0]='AISMALL01'
#通过del删除元素
del my_list[3]
print("修改后：",my_list)

# 还可以通过切片来修改列表，通过切片进行修改时只能使用序列
my_list[1:3]=['AISMALL02','AISMALL03']
print("修改后：",my_list)

运行结果：
修改前： ['aismall01', 'aismall02', 'aismall03', 'aismall04']
修改后： ['AISMALL01', 'aismall02', 'aismall03']
修改后： ['AISMALL01', 'AISMALL02', 'AISMALL03']

3.1.3，序列的简单操作

• +和*
+可以将两个列表拼接为一个列表
  *可以将列表指定重复次数
• in和not in
in用来检查指定元素是否在列表中，在返回true，不在返回false
  not in用来检查指定元素是否不在列表中，不在返回true，在返回false
• len()获取列表中的元素个数
• min()和max()用来获取列表的最小和最大值
• 两个方法：index()和count
index()获取指定元素在列表中第一次出现时的索引，第二个参数为查找起始位置，第三个参数为查找结束位置，也可以省略。
  count()统计指定元素在列表中出现的次数

3.2，列表（list）

3.2.1，列表的概述

• 列表是Python中的一个对象
• 我们可以把列表类比成java语言中的数组，不同的是java语言中的数组只能存储类型一致的变量（对象），python语言中的列表可以存储任意类型的的对象
• 对象（object）就是内存中专门用来存储数据的一块区域，之前我们学习的对象，像数值，它只能保存一个单一的数据
• 列表中可以保存多个有序的数据
• 列表是用来存储对象的对象
• 列表的使用：
  1.列表的创建：使用中括号
  2.操作列表中的数据
• .1，列表的创建：使用中括号
  列表中存储数据称之为：元素

# 创建列表，使用中括号
my_list=[] # 空列表
print(my_list,type(my_list))

运行结果：[] <class 'list'>

列表中可以保存任意对象，一般我们都存储统一的对象

my_list=[1,2,3,4,5] 
my_list=[1,2,'hello',3,'world'] # 这种一般不用

• 2，操作列表中的数据
  类比java语言中的数组，python中的列表我们也可以通过索引来访问，索引从0开始
  索引可以为负数，-1为倒数第一个，-2为倒数第二个，以此类推

# 向列表中添加多个元素时只用都好分割
my_list=[1,2,3,4,5]
# 使用len()函数获取列表的长度，获取到的长度值为列表的最大索引+1
print(len(my_list))
print(my_list[0])

运行结果：5	1

3.2.2，可变序列（列表）的常用操作方法

append()：向列表的最后添加一个元素
extend()：使用新序列来拓展当前序列，需要使用一个序列作为参数
insert()：向列表中的指定位置添加一个元素
参数：要插入的位置，要插入的元素
clear()：清空序列
pop()：根据索引删除并返回指定元素
remove()：删除指定值得元素，如果同一个值的元素有多个，只会删除第一个
reverse()：反转列表
sort()：用来对列表中的元素进行排序，默认是升序排列
sort(reverse=True)：降序排列

# 创建一个列表
my_list=['aismall01','aismall02']
# 打印修改前的序列
print("修改前：",my_list)

my_list.append('append')
print("修改后：",my_list)

my_list.extend(['extend01','extend02'])
print("修改后：",my_list)

my_list.insert(0,'insert')
print("修改后：",my_list)

pop=my_list.pop(0)
print(pop)

my_list.remove('extend02')
print("修改后：",my_list)

my_list.clear()
print("修改后：",my_list)

运行结果：
修改前： ['aismall01', 'aismall02']
修改后： ['aismall01', 'aismall02', 'append']
修改后： ['aismall01', 'aismall02', 'append', 'extend01', 'extend02']
修改后： ['insert', 'aismall01', 'aismall02', 'append', 'extend01', 'extend02']
insert
修改后： ['aismall01', 'aismall02', 'append', 'extend01']
修改后： []

3.2.3，如何遍历列表

• 遍历列表可以使用循环：while循环或者for循环

while循环遍历列表：

# 创建一个列表
my_list=['aismall01','aismall02','aismall03','aismall04']
# 遍历列表
i=0
while i<len(my_list):
    print(my_list[i])
    i+=1

for循环遍历列表：
语法：

for 变量 in 序列：
	代码块

# 创建一个列表
my_list=['aismall01','aismall02','aismall03','aismall04']
# 遍历列表
for name in my_list:
    print(name)

3.3，元组（tuple）

• 元组是一个不可变得序列
• 它的操作方式基本上和列表是一致的，所以在操作元组时，就把元组当做一个不可变得列表即可
• 一般当我们希望数据比改变的时候就使用元组，其余情况使用列表
• 创建元组使用小括号：my_tuple=(1,2,3,4,5)
• 由于元组是一个不可变的对象，所以不可以尝试给元组重新赋值
• 当元组不为空的时候，括号可以省略：my_tuple=1,2,3,4,5
• 当元组中只有一个元素的时候，要在数据的后面加一个逗号作为区分：my_tuple=1,或者my_tuple=(1,)
• 元组的解包（解构）：将元组中每一个元素都赋值个一个变量
  注意：在对元组进行解包时，变量的数量必须和元组中的元素数量一致，不一致时需要在最后一个变量前面加*，表示使用此变量接受剩余的元组元组中的值

# 创建一个元组
my_tuple=1,2,3
print(type(my_tuple))
a,b,c,d,e=my_tuple
print("a=",a)
print("b=",b)
print("c=",c)
运行结果：
<class 'tuple'>
a= 1
b= 2
c= 3

• 元组解包的应用，交换两个数的值

# 元组解包的应用，交换两个数的值
a=10
b=20

print("交换前")
print("a=",a)
print("b=",b)

# 交换连个数的值,后面的：b,a为元组，前面的：a,b为解包接收元组的值
a,b=b,a

print("交换后")
print("a=",a)
print("b=",b)

运行结果：
交换前
a= 10
b= 20
交换后
a= 20
b= 10

04，可变对象

4.1，可变对象概述

• 每个对象中都保存了三个数据：
  id（标识），也就是内存地址
  type（类型）
  value（值）
• 列表就是一个可变对象：a = [1,2,3]
• a[0] = 10（修改对象，内存地址不变）
  这个操作是在通过变量去修改对象的值
  这种操作不会改变变量所指向的对象
  当我们去修改对象时，如果有其他变量也指向了该对象，则修改也会在其他的变量中体现
• a = [4,5,6]（修改变量，内存地址改变）
  这个操作是在给变量重新赋值
  这种操作会改变变量所指向的对象
  为一个变量重新赋值时，不会影响其他的变量
• 一般只有在为变量赋值时才是修改变量，其余的都是修改对象

a=[1,2,3]
print("修改前:",id(a))
a[0]=10
print("修改对象:",id(a))
a=[4,5,6]
print("修改变量:",id(a))

运行结果：
修改前: 1884729779080
修改对象: 1884729779080
修改变量: 1884729778952

4.2，==和is，!=和is not，的区别

• == 和！=：比较的是对象的值是否相等
• is 和 is not：比较的是对象的id（内存地址）是否相等

05，字典（dict）

5.1，字典概述

• 字典属于一种新的数据结构，称为映射（mapping）
• 字典的作用和列表类似，都是用来存储对象的容器
• 列表存储数据的性能很好，但是查询数据的性能的很差
• 在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素
• 在查询元素时，字典的效率是非常快的
• 在字典中可以保存多个对象，每个对象都会有一个唯一的名字，这个唯一的名字，我们称其为键（key），通过key可以快速的查询这个对象，我们称其为值（value），所以字典，我们也称为叫做键值对（key-value）结构，每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item）
• 字典的创建使用大括号：{}
• 注意：
  字典的键可以为任意不可变对象，例如：int str bool tuple....，但是我们一般使用str
  值可以为任意对象
  字典的键不可以重复，如果重复，后面的会替换掉前面的

# 创建一个字典
dic={} # 创建一个空字典
print(type(dic))

# 字典的键可以为任意不可变对象，值可以为任意对象
dict={'name':'aismall','age':18,'sex':'女'} 
print(dict,type(dict))

5.2，字典的使用

• 创建字典
  第一种方式：使用dict()函数创建字典
  每一个参数都是一个键值对，参数名是键，参数的值就是值，这种方式创建的键都是字符串

# 创建一个字典
dict=dict(name='AISMALL',age=18,sex='女')
print(dict,type(dict))

运行结果：
{'name': 'AISMALL', 'age': 18, 'sex': '女'} <class 'dict'>

第二种方式：通过dict()函数和双值子序列（序列中还是序列：子序列，子序列的值为双值）创建字典

# 创建一个字典
dict=dict([('name','aismall'),('age',18)])
print(dict,type(dict))

运行结果：
{'name': 'aismall', 'age': 18} <class 'dict'>

• 获取字典中的值
  第一种：使用[]通过键来获取字典中的值，使用这种方法获取获取字典中的值，如果键在字典中不存在，会报错KeyError
  第二种：使用get()函数通过键来获取字典中的值，使用这种方法获取字典中的值，如果值不存在不会报错，会返回None

# 创建一个字典
dict={'name':'aismall','age':18,'sex':'女'}
print(dict,type(dict))
print('通过get方法和键来获取字典中的值：',dict.get('hello'))
print('通过[]和键来获取字典中的值:',dict['hello'])


运行结果：
{'name': 'aismall', 'age': 18, 'sex': '女'} <class 'dict'>
Traceback (most recent call last):
通过get方法和键来获取字典中的值： None
print('通过[]和键来获取字典中的值:',dict['hello']) KeyError: 'hello'

• get(key[,default])函数：该方法用来根据键来获取字典中的值
  如果获取的键在字典中不存在，会返回None。
  也可以指定一个默认值，来作为第二个参数，这样如果获取的键在字典中不存在就会返回默认值，而不是None。
• 修改字典
  第一种：使用[]来修改，例如：dict['name']='AISMALL'，使用这种方式，如果key存在则覆盖，不存在则添加。
  第二种：使用setDefault(key[,default])函数，使用这种方式，如果key存在则value值会被返回，不存在则添加
• update([other])函数，将其他字典中的键值对添加到当前字典中，如果有重复的key，则后面的会替换当前的

# 创建一个字典
dict1={'a':1,'b':2,'c':3}
dict2={'c':4,'e':5,'f':6}
print(dict1)
print(dict2)
dict1.update(dict2)
print('使用update方法后：',dict1)

运行结果：
{'a': 1, 'b': 2, 'c': 3}
{'c': 4, 'e': 5, 'f': 6}
使用update方法后： {'a': 1, 'b': 2, 'c': 4, 'e': 5, 'f': 6}

• 删除字典中的元素
  del()函数：删除字典中的键值对，例如：dict.del('a')，a为键值
  popitem()函数：随机删除字典中的一个键值对，一般都会删除最后一个，删除之后会返回删除的键值对，注意：返回的方式是以二元元组的方式
  pop(key[,default])函数：根据key删除字典中的键值对，会将删除的value返回，注意：不设置默认值的时候，删除不存在的key会报错，设置默认值得时候删除不存在的key会返回默认值
  clear()函数：清空字典
• 字典的复制
• copy()函数：该方法用于对字典的浅复制，例如：d2=d.copy()
  注意：浅复制时，复制的对象和原对象是相互独立的（id不同），但是如果被复制的对象内部也是一个可变对象，则这个内部可变对象不会被复制（id相同）。

5.3，字典的遍历

• keys()函数：该函数会返回一个序列，序列中保存的是字典的key
• values()函数：该函数会返回一个序列，序列中保存的是字典的value
• items()函数：该方法会返回字典中的所有项，返回的是一个序列，序列中包含有双值子序列，双值分别为字典的key和value，注意：双值序列是元组的形式，我们可以只用元组解包的方法来获取想要的key和value值

# 创建一个字典
dict={'a':1,'b':2,'c':3,'d':4}
print(dict)
# 遍历字典
# 使用keys()函数
for k in dict.keys():
    print(k,'=',dict[k])

# 使用values()函数
for v in dict.values():
    print(v)

# 使用items()函数,由于双值元素为元组，使用元组解包的方式来获取key和value
for k,v in dict.items():
    print(k,'=',v)

06，集合（set）

6.1，集合的概述

• 集合和列表非常相似
• 不同点：
  1.集合中只能存储不可变对象
  2.集合中存储的对象是无序（不是按照元素的插入顺序保存）
  3.集合中不能出现重复的元素
• 集合中不可存储列表（列表可变）
• 集合的创建
  第一种：使用大括号创建集合{}
  第二种：使用set()函数结合列表或者字符串或者字典来创建集合

# 创建一个集合
s={1,2,3,5,6}
print(s,type(s))

s1=set()  # 空集合

s2=set([1,2,3,5,6]) # 通过列表创建集合
print(s2,type(s2))

s3=set({'a':1,'b':2,'c':3}) # 通过字典创建集合，注意，只会包含字典中的key值
print(s3,type(s3))

运行结果：
{1, 2, 3, 5, 6} <class 'set'>
{1, 2, 3, 5, 6} <class 'set'>
{'c', 'b', 'a'} <class 'set'>

6.2，集合的操作

• add()函数：向集合中添加元素
• update()函数：将一个集合添加到当前集合，例如：s.update(s2)
• pop()函数：随机删除并返回集合中的一个元素
• remove()函数：删除集合中的指定元素
• clear()函数：清空集合
• copy()函数：浅复制集合

6.3，集合的运算（了解）

• 对集合做运算时，不会影响原来的集合，而是返回一个运算结果
• &：交集运算
• |：并集运算
• -：差集运算
• ^：异或运算
• <=：检查一个集合是否为另一个集合的子集
• <：检出一个集合是否是另一个集合的真子集
• >=：检查一个集合是否为另一个集合的超集
• >：检查一个集合是否为另一个集合的真超集