编程
语言：
事物与事物之间沟通交流的媒介
计算机：
解放人力，代替人力去工作
古代，雇工代替自己工作
现代，使用计算机代替自己工作
编程：
1.什么是编程
编程就是编写程序，人将自己的思维逻辑通过计算机能够识别的语言写下来，让计算机按照人的思维逻辑去干活的编辑代码
电脑，人工智能是开发的一个方向
编程的代码存放在文件中
计算机是死的，不会主动去干活
编程语言：
shell
python
go
一套完整的计算机系统有以下三部分组成：（系统层面）
1.应用程序 ---- 程序员
2.操作系统 ---- 中间人，调用
3.计算机硬件
PS：
1.程序员开发的程序都叫应用程序
2.操作系统也叫应用程序，但是它针对的是计算机硬件
计算机硬件：
CPU
内存
硬盘
操作系统：
帮助人去操作硬件，操作系统本身已经封装好了一系列操作硬件的方法，程序员只需要按照操作系统提供的方法间接的操作硬件
Windows
linux
计算机五大组成部分：（硬件层面）
1.控制器 计算机的控制系统
2.运算器 计算机的运算系统
逻辑运算
判断事物对错
数学运算
数字运算
控制器+运算器=计算器中央处理器（CPU）
3.存储器 计算机的存储系统
内存（10ns）
优点：基于电工作，读取速度快
缺点：断电数据丢失
外存，硬盘（10s）,靠磁针旋转读取数据（机械硬盘），SSD固态硬盘，磁带（便宜）
优点：永久保存数据
缺点：读取数据较内存慢
高速缓存（2ns），<4MB
寄存器（1ns），速度最快，容量最小<1KB
PS：
输入设备也称input，输出设备也叫output
存储器也可以叫做IO设备
4.输入设备
键盘、鼠标、触摸板
5.输出设备
显示器、音响、打印机
BIOS：
计算机主板出厂的时候自带的一个系统
python解释器运行一个py文件的步骤：
1.将py解释器的代码由硬盘读取到内存
2.将py文件以普通文件的形式读到内存，展示给用户
3.python解释器读取文件内容，识别python语法，执行相应的操作
ps：普通的文本编辑器与python解释器的前两步都是一样的
#双击一个图标 （告诉操作系统帮你去操作硬件）
1.该软件对应的数据有硬盘读到内存
2.CPU去内存中读取该软件对应的数据
3.给用户的感觉，这个软件起来了
#文件的概念
文件就是计算机暴露给用户的操作硬件的接口
CPU
计算机是基于电工作的，而电信号只有高低电平两种状态
0100010001001010010 所以计算机里面存储的都是0101这样的二进制数据
CPU的工作流程：
使用内存，读取命令，将命令解析成操作步骤，控制硬件执行
CPU分类：
精简指令集CPU
这种CPU的微指令集较为精简，执行效果较好
复杂指令集CPU
X86架构是CPU以80开头的代号的一个统称
32位，CPU到内存中读取数据，一次最少读32位
64位
64位向下兼容32位的软件，而32为不能兼容64位的软件
操作系统
操作系统：
操作系统也是一个应用软件，但是它是针对计算机硬件的
作用：
将复杂的操作封装起来，暴露给用户简单快捷的操作接口，便于操作计算机硬件
帮助用户协调、管理、调度计算机各个硬件
文件：
操作文件就是在操作硬盘
注释
什么是注释
注释就是对代码的解释或评论，通常在代码前面说明，注释是给人看的，计算机不会解析
分类：
1.单行注释
# 内容
2.多行注释
'''内容'''
"""内容"""
输入
1.python3中的输入
关键字input()
python3中的input()获取的用户输入，统一全部存成字符串类型
2.python2中的输入
input()
需要人为的告诉python程序，输入的是什么数据类型 'str' 10 [1,2,3] {4,5,6}
raw_input()
python2中的raw_input()和python3中的input()一样，无论用户输入的是什么数据类型，统一转变成字符串类型
输出
name = input('your name >>>:')
age = input('your age >>>:')
1.单行打印
print(name,age)
2.多行打印
print(name)
print(age)
3.占位符，指定格式打印
print('my name is',name,'my age is',age)
print('my name is %s,my age is %s' %(name,age))
%s 既能给字符串占位，又能给整形占位（可以给任意数据类型占位），变量的个数不能多也不能少
%d 只能给数字占位
print('%08d' %123)
%08d 整数是8位，传入的数不够8位得到话默认用0补全，超出8位的话，是多少就是多少
#print() ,打印空行、换行
数据类型
什么是数据：
衡量/记录事物的状态/特征
什么是类型：
不同的数据应该用不同的数据类型存储，比如：文本，视频，音频...
整型、浮点型
int 整形，整数
age = 18 #本质上是 age = int(18)
#age = int('18') #字符类型转换
print(type(age))
float 浮点型，带小数位
salary = 1.11 #本质上是 salary = float(1.11)
#salary1 = float(3.11)
print(type(salary))
复数
a = 1-2j
type(a)
a.real #查看实部
a.imag #查看虚部
#只有python2中有长整型，python3中只有整形
#print(1+2)
#整型、浮点型可以统称为数字类型
#有返回值的时候，可以直接print()
#没有返回值的时候，只能print()作用对象
x = [1,2,3]
x.clear()
print(x) #[]
print(x.clear()) #None,函数没有返回值
字符串类型
作用：
保存描述信息，比如：个人简介、对他人的评价...
表示方法：
1.单引号
s1 = '我是一个字符串' #本质上是 s1 = str('我是一个字符串')
print(type(s1))
2.双引号
s1 = "我是一个字符串"
3.三引号
s1 = '''我是一个字符串'''
s1 = """我是一个字符串"""
#字符串之所以有三种定义方式，这是考虑到用户在输入的文本中也需要用到引号
print(hello+world)
print(hello*5)
#python中字符串可以加减乘除，原理是在内存中申请了名称空间
列表类型
作用：
能够存储多个数据，并且可以方便的取出一个或多个
定义：
[]内部通过逗号分隔多个元素，并且这多个元素可以是任意的数据类型
l = [123,3.1,'syy',[11,22]]
#取值
索引取值
print(l[0])
print(l[3][0]) #本质是 print([11,22][0])
#列表也可以直接相加减
print([1,2,3]+[4,5,6])
字典类型
作用：
能够存储多组数据，存取的数据都有对应的描述
定义：
大括号内存多个元素，元素的格式key:value形式存储，键值对与键值对之间使用逗号隔开，字符串加引号，整形、浮点型不用加引号
key通常是描述value的描述性信息，所以key通常存的就是字符串（不可变类型、可hash）
value通常就是描述性信息对应的真实的数据
字典中的元素是没有顺序的
字典暴露给用户的部分只有key，所以字典取值必须要知道key
#字典的定义方式1
info = {
'name': 'syy',
'age':18,
'hobby':['妹子'，‘钱’]
}
#本质是
info = dict{
...
}
#字典的定义方式2
info = dict(name='syy',age=18)
print(info,type(info)) #{'name': 'syy', 'age': 18} <class 'dict'>
#字典的定义方式3
info = [
['name','syy'],
['age',18],
['hobby','qiu']
]
d = {}
for i in info:
d[i[0]] = i[1] #字典中不存在，就直接添加
print(d)
info = [
['name','syy'],
['age',18],
['hobby','qiu']
]
d = {}
for k,v in info: #使用解压赋值，定义字典
d[k] = v
print(d)
info = [
['name','syy'],
['age',18],
['hobby','qiu']
]
d = dict(info) #该方法本质上使用的仍是for循环
print(d)
#字典取值,类似于列表取值
#但是必须指定key（字典的取值使用for循环比较方便），for循环可以不使用索引取值，可以更方便的取出字典中的value
emp_info = dict{
'name':'syy',
'age':18'
'sex':'male',
'company_info':{
'cname':'OB',
'emp_count':200,
'addr':'SH'
}
}
print(emp_info['company_info']['addr'])
d = {'name':'syy','age':18}
print(d.keys()) #keys()本质上是一个迭代器
for i in d.keys():
print(i,d[i])
d = {'name':'syy','age':18}
print(d.values())
for i in d.values(): #使用value()函数，直接取值
print(i)
d = {'name':'syy','age':18}
print(d.items())
for i in d.items(): #结果是一个列表（迭代器）
print(i) #dict_items([('name', 'syy'), ('age', 18)])
#字典中重复定义键，字典中的key唯一表示value，不能重复
d = {'name':'syy','name':'zhangsan','name':'lisi','age':18}
print(d) #{'name': 'lisi', 'age': 18}
#使用len()函数，统计字典中键值对的个数
d = {'name':'syy','name':'zhangsan','name':'lisi','age':18}
print(len(d))
#字典和字符串、列表、元组一样，都是可变的数据类型
d = {'name':'syy','name':'zhangsan','name':'lisi','age':18}
print(id(d))
d[0] = 'wang'
print(id(d))
#在字典中添加键值对
d = {'name':'syy','age':18}
d['habby'] = 'qiu'
print(d)
#成员运算,注意字典暴露给用户的只有key，取值也要通过key
d = {'name':'syy','age':18}
print('name' in d) #True
#删除字典，或者删除字典内的元素
d = {'name':'syy','age':18}
del d['name']
print(d) #{'age': 18}
d = {'name':'syy','age':18}
d.pop('name')
print(d)
d = {'name':'syy','age':18}
print(d.pop('name')) #syy，pop()的返回值是key对应的value
d = {'name':'syy','age':18}
print(d.pop('namesyy')) #KeyError: 当键不存在的时候直接报错
-------------------------------------------------------------------------------
#get()函数，根据key获取value
d = {'name':'syy','age':18}
print(d.get('name')) #syy
print(d.get('pas')) #None,不报错
d = {'name':'syy','age':18}
print(d.get('name')) #syy
print(d.get('pas','这个键不在字典中')) #这个键不在字典中
#fromkeys()函数，快速生成字典
print(dict.fromkeys('wer',123)) #{'w': 123, 'e': 123, 'r': 123}
print({}.fromkeys('wer',123)) #{'w': 123, 'e': 123, 'r': 123}
d = ['name','syy','age',18] #使用列表生成字典
print(dict.fromkeys(d,123)) #{'name': 123, 'syy': 123, 'age': 123, 18: 123}
#面试题
#使用append()可以修改字典的value
#注意使用forkeys()函数快速生成函数中，名值对的指向关系
x = {}.fromkeys(['name','pas'] ,[])
print(x) #{'name': [], 'pas': []}
print(x['name'].append('zhangsan')) #None
print(x) #{'name': ['zhangsan'], 'pas': ['zhangsan']}
x = {}.fromkeys(['name','pas'] ,[])
print(x)
x['name'] = 'zhangsan'
print(x) #{'name': 'zhangsan', 'pas': []}
#popitem()函数，从字典尾部弹出键值对
d = {'name':'syy','age':18}
print(d.popitem())
print(d.popitem())
#setdefault()函数，返回值是键对应的key
d = {'name':'syy','age':18}
print(d.setdefault('name','zhangsan')) #键存在就算了
print(d)
print(d.setdefault('hobby','qiu')) #键不存在就添加键值对
print(d)
syy
{'name': 'syy', 'age': 18}
qiu
{'name': 'syy', 'age': 18, 'hobby': 'qiu'}
#update()函数，修改字典中的键值对
d = {'name':'syy','age':18}
d['age'] = 20 #存在就替换，不存在就添加
print(d)
d = {'name':'syy','age':18}
d.update(age=20)
print(d)
x = {}.fromkeys(['name','pas'] ,[])
y = {'name':'zhangsan'}
print(x)
x.update(y)
print(x)
布尔值
作用：
表示事物的对错，通过true和false，判断事物的对错、是否可行
定义：
tag1 = True #本质是 tag1 = bool(True)
tag2 = False
#计算机所有的逻辑运算，都要转化为布尔值
#True、False 首字母要大写
x = 10
y = 10
print(x == y)
#python中，一个等号'=' 是赋值，两个等号'=='是比较，注意比较的是value
print(x is y)
#is 比较的是两个变量对应的id（内存中的名称空间的名字）是否相等（注意相同的值的名的指向问题）
id相等的情况下，值一定相等
id不相等的情况下，值有可能相等
a = 1
b = 1
print(id(a))
print(id(b))
print(a is b) #True
#'变量名'和布尔值可以直接用于if判断
'变量名'指向的值对应的就是True和False（a = True）
整型、浮点型、字符串等都可以直接作为条件，用于if判断、while循环
元组
作用：
能够存储多个元素，元素与元素之间使用逗号隔开
元组一旦被定义，那么就不会再被修改，使用场景跟列表不同
#元组内可以存放任意数据类型
#如果元组内只有一个元素，定义的时候一定要加一个逗号
#存储相同的资源，内存的使用列表较高
格式：
x = () #空元组
x = (int,float,str,list,dict...)
x = tuple([1])
print(x) #(1,),该方式定义元组，后面只能跟容器类型
x = (1)
print(type(x)) #<class 'int'>，实际上是定义了整型
x = (1,)
print(type(x)) #<class 'tuple'>，定义元组
#元组中的元素是不能修改的
x = (['1'],)
x[0] = 1
print(x) #TypeError: 元组是不能修改的
x = (['1'],)
x[0][0] = '哈哈'
print(x) #(['哈哈'],)，元组内的'容器类型内的数据'是可以修改的
x = (['1'],)
del x
print(x) #NameError: 元组可以被删除
#元组的索引取值
x = (1,2,3)
print(x[0]) #返回的数据类型，即为元组内元素的数据类型
#元组的切片
x = (1,2,3)
print(x[0:1:]) #(1,)，返回一个元组
#成员运算in/not in
x = (1,2,3)
print(1 in x) #True
#元组的内置方法
x = (1,2,3)
print(x.count(1))
x = (1,2,3)
print(x.index(2))
#元组跟列表一样，都是可变的数据类型
x = (1,2,[3])
print(id(x))
x[-1].append(233)
print(x)
print(id(x))
#只要定义的是容器类型（列表、字典、元组），如果内部只有一个元素，那么，最好在后面加上一个逗号
#元组和列表对比：
存储相同数据量的情况下，元组更加节省空间
集合
作用：
群体之间作比较，不涉及单个元素 --- 关系运算（共同好友、共同关注）
一个集合可以包含多个元素，元素之间使用逗号分隔
集合中的每个元素必须是不可变类型（整型、浮点型、字符串、元组）
集合中'没有'重复的元素 --- 去重
集合中的元素是无序的
格式：
{} #空字典
set{} #空集合
a = {1,2,'syy',()}
print(type(a)) #set
#交集
python = ['jason','nick','syy','tank','egon','kevin','owen','alex']
linux = ['frank','jerry','tank','egon','alex']
for i in python:
if i in linux:
print(i)
#差集，一个集合的非交集元素
python = ['jason','nick','syy','tank','egon','kevin','owen','alex']
linux = ['frank','jerry','tank','egon','alex']
for i in python:
if i not in linux:
print(i)
#把字符串转换成集合
print(set('111')) #{'1'}
#把列表转化成集合
a = [1,2,3,3,2,1]
print(set(a)) #{1, 2, 3}
#把元组转换成集合
print(set((1,))) #{1}
#交集
python = {'jason','nick','syy','tank','egon','kevin','owen','alex'}
linux = {'frank','jerry','tank','egon','alex'}
print(python & linux) #{'egon', 'alex', 'tank'}
#差集，只报名python
python = {'jason','nick','syy','tank','egon','kevin','owen','alex'}
linux = {'frank','jerry','tank','egon','alex'}
print(python - linux) #{'jason', 'owen', 'nick', 'syy', 'kevin'}
#差集，只报名linux
python = {'jason','nick','syy','tank','egon','kevin','owen','alex'}
linux = {'frank','jerry','tank','egon','alex'}
print(linux - python) #{'frank', 'jerry'}
#对称差集，交集的补集
python = {'jason','nick','syy','tank','egon','kevin','owen','alex'}
linux = {'frank','jerry','tank','egon','alex'}
print(python ^ linux) #{'jason', 'owen', 'nick', 'jerry', 'frank', 'kevin', 'syy'}
#两个集合相加，再去重
python = {'jason','nick','syy','tank','egon','kevin','owen','alex'}
linux = {'frank','jerry','tank','egon','alex'}
print(python | linux) #{'jason', 'syy', 'owen', 'kevin', 'frank', 'egon', 'jerry', 'nick', 'tank', 'alex'}
python = {'jason','nick','syy','tank','egon','kevin','owen','alex'}
linux = {'frank','jerry','tank','egon','alex'}
print(python + linux) #TypeError: 不能使用符号+
#集合中元素是没有顺序的
a = {1,2,3}
b = {3,2,1}
print(a == b) #True
#父集
a = {1,2,3}
b = {1}
print(a >= b) #True，集合a，包含集合b
a = {1,2,3}
b = {1}
print(a <= b) #False
#向集合内添加元素
a = {1,2,3}
a.add(666) #add()函数没有返回值
print(a)
a = {1,2,3}
a.add((666,)) #添加元组
print(a)
#在集合中删除元素
a = {1,2,3}
a.remove(1) #元素不存在的话会报错
print(a)
a = {1,2,3}
a.discard(1) #元素不存在的话不会报错
print(a)
数据类型的转换
其他数据类型转int类型
python中常见的数据类型有整型int、浮点型float、字符串str、列表list、字典dict
#字符串转int类型
res = int('str')
print(res)
res = int('str111')
print(res)
res = int('1.11')
print(res)
res = int('111') #字符串含有字母、特殊符号的类型不能转int类型，字符串纯数字字符串类型可以转int类型
print(res)
#浮点型转int类型
res = int('1.11') #浮点型、列表、字典不能转int类型
print(res)
其他数据类型转浮点型
#字符串转float浮点型
res = float('111')
print(type(res))
print(res) #111.0
res = float('1.11')
print(type(res))
print(res) #1.11，整型、字符串（整型字符串、浮点型字符串）可以转浮点型，列表、字典不能转浮点型
其他数据类型转字符串
#整型转字符串类型
s1 = 111
print(type(str(s1)))
#浮点型转字符串类型
s2 = 11.1
print(type(str(s2)))
#列表转字符串类型
s3 = [1,2,3]
print(type(str(s3)))
#字典转字符串类型
s4 = {'name':'syy','age':18}
print(type(str(s4)))
#别的数据类型都可以转字符串类型
其他数据类型转列表
#整型、浮点型不能转列表类型
res = list(111)
print(type(res))
print(res) #TypeError:
#字符串转列表类型
res = list('111a')
print(type(res))
print(res) #['1', '1', '1', 'a']
#字典类型转列表类型
res = list({'name':'syy','age':18})
print(type(res))
print(res) #['name', 'age']
其他数据类型转元组
#整型、浮点型转元组
x = tuple(1)
print(x) #TypeError:
#字符串类型转元组
x = tuple('1')
print(x) #('1',)
#列表转元组
x = tuple([1,])
print(x) #(1,)
#字典转元组
x = tuple({'name':'syy' })
print(x) #('name',)
进制转换
#二进制转十进制
规律：
10 # 1*(2**1) + 0*(2**0) = 2 ,所以二进制数10用十进制数表示就是2
#八进制转十进制
规律：
10 # 1*(8**1) + 0*(8**0) = 8,所以八进制数10用十进制数表示就是8
#十六进制转十进制，十六进制数由 0-9 a-f组成
规律：
10 # 1*(16**1) + 0*(16**0) = 16 ,所以十六进制数10用十进制数表示就是16
-------------------------------------------------------------------------
#十进制转二进制，使用函数bin()，0b表示后面的数是二进制
print(bin(10)) #0b1010
#十进制转八进制，使用函数oct()，0o表示后面的数是八进制
print(oct(10)) #0o12
#十进制转十六进制，使用函数hex()，0x表示后面的数是十六进制
print(hex(10)) #0xa
-------------------------------------------------------------------------
#使用函数，其他进制转十进制
print(int('1010',2))
print(int('12',8))
print(int('a',16))
数据的可变类型与不可变类型
可变类型：
值改变的情况下，id不变，说明改的是原值
不可变类型：
值改变的情况下，id一定变，说明改的是名对值的指向
#整型是不可变类型
x = 10
print(id(x))
x = 11
print(id(x))
#浮点型是不可变类型
x = 10.1
print(id(x))
x = 11.1
print(id(x))
#字符串是可变数据类型
x = 'syy'
print(id(x))
x.replace('s','z')
print(id(x))
#列表是可变类型
x = [10.1]
print(id(x))
x[0] = 11.1
print(id(x))
#元组是可变数据类型
x = (1,2,[3,4])
print(id(x))
x[2][0] = 33
print(id(x))
#字典是可变类型
x = {'name':'syy','age':18}
print(id(x))
x[1] = 19
print(id(x))
索引取值
#整型的索引取值
s = 123
print(s[0]) #不支持
#浮点型的索引取值
s = 123.1
print(s[0]) #不支持
#字符串的索引取值
s = 'hello world'
print(s[0]) #h
#列表的索引取值
s = [1,2,3]
print(s[0])
s =[1,2,3]
print(s[0::]) #相当于print(s[0:3:1])
s =[1,2,3]
print(s[2::-1]) #[3, 2, 1],注意末尾索引可以不写
s =[1,2,3]
print(s[-1::-1]) #[3, 2, 1]，注意，右索引从-1开始
#字典的取值，因为在字典中键值对是没有顺序的（没有索引），所以字典不能通过索引取值，只能通过key取值
s = {'name':'syy','age':18}
print(s['name'])
#列表、元组、字典等容器类型可以使用解压赋值
k,v = [1,2]
print(k,v) #1 2
k,v = {'name':'syy','age':18}
print(k,v) #name age
k,v = (1,2)
print(k,v) #1 2
切片
#整型的切片
s = 1101111
print(s[0:3]) #不支持
#浮点型的切片
s = 110.11111
print(s[0:3]) #不支持
#字符串的切片
s = 'hello world'
print(s[0:3]) #hel，顾头不顾尾
s = 'hello world'
print(s[0:3:1]) #默认切片的步长为1，每个都取
s = 'hello world'
print(s[0:3:2]) #步长为2，那么隔一个取一个
#列表的切片
s = [1,2,3,4,5,6]
print(s[0:3:2]) #[1, 3]
#字典的切片
s = {'name':'syy','age':18,'habby':'qiu'}
print(s[0:2]) #不支持
#切片中的负数问题(索引、步长都支持负数)
s = 'hello world'
print(s[0:5:-1]) #代码没有返回值，原因是索引0左边没有索引
s = 'hello world'
print(s[5:0:-1]) # olle，从索引5开始，向左边数，顾头不顾尾（左头右尾）
s = 'hello world'
print(s[-1:-5:-1]) #dlro，从右边数的话，第一个索引为-1不是0
#数据类型支持索引，才能使用切片，所以，只有字符串、列表、元组支持切片
len()函数的使用对象
#整型
s = 111
print(len(s)) #不支持
#浮点型
s = 11.1
print(len(s)) #不支持
#字符串
s = 'hello world'
print(len(s)) #统计字符串中字符的个数（空格算一个字符）
#列表
s = [1,2,3] #统计列表中元素的个数
print(len(s))
#字典
s = {'name':'syy','age':18} #统计字典中键值对的个数
print(len(s))
成员运算 in和 not in
#整型
print('18' in 'syy is 18 year') #True
#浮点型
print('18.1' in 'syy is 18.1 year') #True
#字符串
print('sy' in 'syy is 18 year')
print('syy' in 'syy is 18 year') #True
print('jason' not in 'syy is 18 year')
#列表
print('[18]' in 'syy is [18] year') #True
#字典
print('age' in {'age':18}) #True
print('18' in {'age':18}) #False
#在列表中，每个元素都是最小的单元
a = ['name','syy']
print('name' in a) #True
print('n' in a) #False
print('n' in a[0]) #True
#只有字符串才能使用in/not in
字符串中的空格
#strip()作用：
去除空格
#strip(),默认去除字符串首尾的空格，不能去除中间的空格
x = 'syy'
y = ' syy '
print(x)
print(y.strip())
#使用strip()函数去除字符串首尾的指定字符，可以一次去除多个字符
x = 'syy'
y = '000syy000'
print(x)
print(y.strip('0s'))
#strip()函数的操作对象只能是字符串
#strip()函数可以接受多个字符，但是必须放到一个''内（想去除什么，就在里面加什么）
#strip()函数去除多个字符的时候，只能在首/尾去掉的前提下去除多个字符
#strip()函数通常与input()函数连用，input().strip()，防止用户输入的时候输入空格，导致程序匹配异常
#lstrip()函数，只作用于字符串的左边，直到遇到不是指定的去除字符
#rstrip()函数，只作用于字符串的右边
replace()函数
作用：
替换
格式
str.replace(old, new[, max])
参数
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次，默认替换所有
#使用replace()函数，去除用户输入的空格
x = 111
y = ' syy '
print(x)
print(y.replace(' ','',3))
#替换字符串中的字符
str = 'my name is syy,syy age is 18'
print(str.replace('syy','wang'，1))
#整型、浮点型、列表、字典不能使用replace()函数，只有字符串可以使用replace()函数
split() 函数
作用：
对指定字符串，指定字符切片
格式一：
str = 'syy is age 18'
print(str.split()) #['syy', 'is', 'age', '18'] ，默认以空格为分隔符
格式二：
data = 'syy|123|student'
print(data.split('|')) #['syy', '123', 'student']
usernmae,password,info = data.split('|') #解压赋值
格式三：
data = 'syy|123|student'
print(data.split('|',1)) #['syy', '123|student']
#整型、浮点型、列表、字典都不能使用split()函数
#split()函数对字符串切分，结果是一个列表
#切割的顺序是从左向右
#默认num=-1，指定字符串切割所有
#lsplit()函数，从左边切字符串，默认
#rsplit()函数，从右边切字符串
join()函数
#把字符串中的字符拼接成字符串
data = 'syy'
print('$'.join(data)) #s$y$y
#把字符串切片，变成列表
data = 'syy|123|student'
print(data.split('|'))
#对字符串切片变成列表，在把列表拼接成字符串
s = data.split('|')
print('$'.join(s)) #字符串syy$123$student
#整型、浮点型不能使用join()函数拼接
#列表可以使用join()函数，但是里面的元素要注意不能是整型、浮点型
#字典也可以通过join()函数，拼接key
l = ['1','a','b'] #小心1
print('|'.join(l))
lower()、upper()函数
#字符串所有字母转小写
s = 'Syy'
print(s.lower())
#字符串所有字母组转大写
s = 'Syy'
print(s.upper())
#这两个函数只能针对字符串，包括含有数字的字符串、含有特殊字符的字符串
#这两个函数可以解决用户登录的时候输入的大小写的问题
#这两个函数没有改变字符串本身，改变的只是返回结果，该函数使用的是返回值
startswith()、endswith()函数
#判断字符串是不是以...开头
s = 'my name is syy'
print(s.startswith('my')) #True
#判断字符串是不是以...结尾
s = 'my name is syy'
print(s.endswith('syy')) #True
#这两个函数只能针对字符串，包括含有数字的字符串、含有特殊字符的字符串
#这两个函数没有改变字符串本身，改变的只是返回结果
#应用场景是，VIP用户、黑名单用户
format()函数的三种玩法
#按位置占位，跟%s原理一样
s = 'my name is {},my age is {}'.format('syy',18)
print(s)
#按索引占位
s = 'my name is {0},my age is {1}'.format('syy',18)
print(s)
#指名道姓的占位，关键字传参
s = 'my name is {name},my age is {age}'.format(name='syy',age=18)
print(s)
find()函数
#判断字符串是否含有某个字符，
如果返回值 n>=0，代表该字符串含有指定的字符，并且指定字符的索引为n
如果返回值是 -1.代表该字符串没有指定的字符
#格式：(限制查找范围，顾头不顾尾)
str.find('s',n,m)
str = 'my name is syy,syy age si 18'
print(str.find('syy')) #11
#使用 in，可以判断一个字符串是否含有某个字符
str = 'my name is syy,syy age si 18'
if 'syy' in str:
print('在')
else:
print('不在')
#只有字符串才能使用find()函数，返回索引值
#该函数不报错
index()函数
#该函数类似于find()
#只能作用于字符串，返回索引值
str = 'my name is syy,o age is 18'
print(str.index('age',0,3))
#该函数会报错
count()函数
作用：
计算字符串中某个字符出现的次数
#只能作用于字符串、列表、元组，不能作用整型、浮点型、字典
格式：(限制查找范围，顾头不顾尾)
str.count('s')
#统计字符串中某个字符的个数
str = 'my name is syy,o age is 18'
print(str.count('syy'))
#统计列表中某个元素的个数
x = [1,2,3,3,2,1]
print(x.count(1))
center()、ljust()、rjust()函数
作用：
center(),把字符串居中，然后填充指定字符
ljust(),把字符串居左，然后填充指定字符，相当于左对齐
rjust(),把字符串居右，然后填充指定字符
zfill(),把字符串居右，然后填充0
格式：
str.center(N.'*')
str = 'syy'
print(str.center(10,'*'))
str = 'syy'
print(str.zfill(10)) #0000000syy
#N的值随意，不报错,代表所有字符的总数
#当填充奇数位个字符的时候，左少右多
expandtabs()函数
作用：
打印出指定个数的TAB键
只能针对字符串中的
格式：
str.expandtabs(N)
str = 'syy 18'
print(str.expandtabs(2))
captalize()、swapcase()、title()函数
作用：
captalize(),把字符串整合成首字母大写，其他位小写的格式
swapcase(),把字符串大小写互换
title(),每个字母首字母大写，其他位小写
只能针对字符串
格式：
str.capitalize()
str.swapcase()
str.title()
str = 'hELlo WoRld'
print(str.capitalize()) #Hello world
str = 'hELlo WoRld'
print(str.swapcase()) #HelLO wOrLD
str = 'hELlo WoRld'
print(str.title()) #Hello World
is数字系列
作用：
判断字符串是否为数字，并且是纯数字，返回True/False
isnumeric()，识别阿拉伯数字、中文数字
is数字系列的作用与isdigit()函数类似，通常情况下使用isdigit()函数就可以满足需求
格式：
num.isnumeric()
num.isdecimal()
num.isdigit() #既支持普通的阿拉伯数字，也支持二进制数字
#isnumeric()函数
num1 = b'4' #bytes，二进制数
num2 = u'4' #Unicode，python3中无需加u就是Unicode
num3 = '肆' #中文数字
num4 = 'IV' #罗马数字
print(num1.isnumeric()) #不识别
print(num2.isnumeric()) #True，识别
print(num3.isnumeric()) #True，识别
print(num4.isnumeric()) #False，不识别
isdigit() 函数
作用：
判断用户的输入是否为纯数字字符串类型，可以直接作为条件，在if判断、循环
while True:
age = input('请输入你的年龄>>>: ')
if age.isdigit():
age = int(age)
if age > 30:
print('阿姨好')
else:
print('小姐姐好')
else:
print('请你他妈的好好输!!!')
list()函数
作用：
#作用对象只能是字符串、字典，不能是整型、浮点型
#内部的原理就是for循环取值，再把值添加到列表中
l = 'syy'
print(list(l)) #['s', 'y', 'y']
l = [1,2,3]
print(list(l)) #[1, 2, 3]
l = {'name':'syy','age':18}
print(list(l)) #['name', 'age']
向列表中添加元素 --- 3中方法
#整型、浮点型、字符串、字典不能使用append()，列表可以
#append()一次只能向列表中添加一个元素，可以是整型、浮点型、列表、字符串、字典
#使用append()函数，向列表的'末尾'添加元素,列表本身改变
x = [8，9,10]
x.append(11)
print(x) #[8, 9, 10, 11]
#整型、浮点型、字符串、字典不能使用insert()，列表可以
#insert()一次只能向列表中添加一个元素，可以是整型、浮点型、列表、字符串、字典
#使用insert()函数，使用索引向列表的任意位置'前'添加元素，列表本身改变
x = [8,9,10]
x.insert(1,110)
print(x) #[8, 110, 9, 10]
x = [8,9,10]
x.insert(-1,110)
print(x) #[8, 9, 110, 10]
#整型、浮点型、字符串不能使用extend()，列表、字典可以
#extend()一次可以向列表中添加多个元素，可以是整型、浮点型、列表、字符串、字典
#使用extend()函数，向列表的'末尾'添加元素,列表本身改变
#extend()函数本质上使用的是for循环+append()函数
x = [8,9,10]
x.extend([1,2,3])
print(x) #[8, 9, 10, 1, 2, 3]
x = [8,9,10]
x.extend({'name':'syy'})
print(x) #[8, 9, 10, 'name']
print([1,2,3]+[2,3,4]) #[1, 2, 3, 2, 3, 4]
在列表中删除元素 --- 3中方法
#整型、浮点型、字符串、列表、字典都可以使用关键字del删除字符、元素
#删除整型、浮点型本身
x = 111
del x
print(x)
#删除字符串本身
x = 'syy'
del x
print(x)
#删除列表中的元素
x = [8,9,10]
del x[1]
print(x)
#删除字典中的键值对
x = {'name':'syy'}
del x['name']
print(x)
#整型、浮点型不能使用pop()函数，列表、字典可以使用pop()函数
#作用是，默认从列表或字典的末尾弹出元素、键值对，删除的时候有返回值
#当pop(N)指定索引时，则弹出指定索引对应的元素
#可以使用在用户退出登录的界面
x = [1,2,3]
print(x.pop()) #3
print(x) #[1, 2]
print(x.pop()) #2
#整型、浮点型、字符串、字典不能使用remove()，列表可以
#作用是删除列表中指定的元素，删除的时候没有返回值
x = [1,2,3]
x.remove(2)
print(x) #[1, 3]
reverse()函数
作用：
将列表中的元素、键值对反向排列
#reverse()函数只能作用于列表，不能作用于整型、浮点型、字符串、字典
#reverse()函数没有返回值
格式：
str.reverse()
x = [1,2,3]
x.reverse()
print(x) #[3, 2, 1]
print(x.reverse()) #None
#列表是可变数据类型
x = [1,2,3]
print(id(x))
x.reverse()
print(id(x))
sort()函数
作用：
将列表中的数据排列
#只能针对列表，默认升序排列
格式：
str.sort()
str.sort(reverse=True)
x = [1,2,3,3,2,1]
x.sort()
print(x) #[1, 1, 2, 2, 3, 3]
print(x.sort()) #None
clear()函数
#作用：
清空列表内的元素
只能作用于列表，字典，不能用于清空整型、浮点型、字符串、元组
#格式：
list.clear()
#清空列表
a = ['123']
a.clear()
print(a)
#清空字典
a = {'name':'syy'}
a.clear()
print(a)
运算
运算符
数学运算：
print(10 + 3)
print(10 - 3)
print(10 * 3)
print(10 / 3) #结果保留小数部分
print(10 // 3) #只保留整数部分
print(10 % 3) #取余数
print(10 ** 3) #次方
#python对数字运算的敏感度不高
比较运算：
==
!=
>
<
>=
<=
print(10 != 9)
字符串的运算，（阿斯克码）
a = 'hello'
b = 'z'
print(b>a) #True，原理是asicII码,A-Z a-z
增量运算
xxx +=1 #等于 xxx = xxx +1
xxx -=1
xxx *=1
xxx /=1
xxx %=1
链式赋值,原理是变量名对id的指向
m =1
n =m
print(m) #1
print(n) #1
m =111
print(n) #1
交叉赋值
m,n = n,m
解压赋值
l = [1,2,3,4]
a = l[0]
b = l[1]
c = l[2]
d = l[3]
a,b,c,d = l
#解压赋值中，前面变量的个数与后面的元素的个数必须相同
a,_,_,d = l
#解压部分值，然后赋值，此时 print(_) = 3
a,*_,d = l
#可以使用*_ 代表多个列表中的元素
逻辑运算，and or not #对应与、或、非
print(1 > 0 and 3 > 4) #False
print(1 > 0 or 3 > 4) #True
print(not 1 > 0) #False
流程控制
if判断
if判断：
让计算机像人一样去工作，那么计算机也应该有对事物的对错、真假、是否可行的判断能力，从而做出不同的响应
语法一：
if 条件：
代码1
代码2
#python用缩进来表示代码的归属，同一缩进的代码，称之为代码块
#布尔值为False的数据有哪些，0、None、''、[]、{}
gender = 'female'
age = 24
is_beautiful = True
if gender == 'female' and age > 18 and age < 30 and is_beautiful:
print('小姐姐好漂亮')
print('正常执行结束')
语法二：
if 条件：
代码1
else:
代码2
if gender == 'female' and age > 18 and age < 30 and is_beautiful:
print('小姐姐好漂亮')
else:
print('什么玩意儿')
语法三：
if 条件：
代码1
elif:
代码2
elif:
代码3
else:
代码4
#if ... else ... 和 if ... elif ... else ... 中，只会同时满足一个条件，同时只会执行一个代码块
语法三：
if 条件1:
if 条件2:
...
...
...
#成绩查询
#代码一：
score2 = input('please input your score >>>:')
score = int(score)
if score >= 90:
print('优秀')
elif score >= 80 and score <90:
print('良好')
elif score >= 70 and score <80:
print('普通')
else:
print('其他')
#代码二：
score = input('please input your score >>>:')
score2 = int(score)
if score2 >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('普通')
else:
print('其他')
#模拟登陆
db_username = 'syy'
db_password = '123'
username = input('please input your username >>>:')
password = input('please input your password >>>:')
if username == db_username and password == db_password:
print('登陆成功')
else:
print('登陆失败')
#每个星期的计划
如果今天是Monder,上班
如果今天是Tuesday,上班
如果今天是wednesday,上班
如果今天是Thursday,上班
如果今天是Friday,上班
如果今天是Saturday,出去浪
如果今天是Sunday,出去浪
代码一：
today = input('>>>: ')
if today == 'Monder':
print('上班')
elif today == 'Tuesday':
print('上班')
elif today == 'wednesday':
print('上班')
elif today == 'Thursday':
print('上班')
elif today == 'Friday':
print('上班')
elif today == 'Saturday':
print('出去浪')
elif today == 'Sunday':
print('出去浪')
else:
print('必须输入以下其中一个:
Monder、Tuesday、wednesday、Thursday、Friday、Saturday、Sunday
')
代码二：
today = input('>>>: ')
if today in ['Monder','Tuesday','wednesday','Thursday','Friday','Saturday','Sunday']:
print('出去浪')
elif today in ['Saturday','Sunday']:
print('出去浪')
else:
print('必须输入以下其中一个:
Monder、Tuesday、wednesday、Thursday、Friday、Saturday、Sunday
')
while循环
定义：
只要条件成立，就执行循环体代码，直到条件不成立
作用：
重复的执行一个或多个代码块
语法一：
while 条件:
代码
语法二：
while 条件:
代码
break
语法三：
while 条件:
代码
continue
语法四：
while 条件:
代码1
else:
print('while循环正常结束')
语法五：
#break执行，else后面的代码将不会执行
while 条件:
代码1
break
else:
print('while循环正常结束')
语法六：
while 条件:
代码1
continue
else:
print('while循环正常结束')
#只有当while循环根据条件正常结束才会走else后面的代码块，如果是主动结束（比如：break），那么，将不会走else后面的代码块
死循环:
while True:
print('hello world')
结束循环-- break,结束整个while循环，不会执行后续的代码:
db_username = 'syy'
db_password = '123'
while True:
username = input('please input your username >>>:')
password = input('please input your password >>>:')
if username == db_username and password == db_password:
print('登陆成功')
break
else:
print('登陆失败')
结束循环-- continel,结束本次while循环，不会执行本次后续的代码:
n = 1
while n < 11:
if n == 4:
n+=1
continue
print(n)
n+=1
结束循环的第三种方式-- 改变条件，这种方式会执行后续的代码
m = True
n = 1
while m:
if n == 99:
m = False
print(n)
n+=1
while循环嵌套
代码一：
db_username = 'syy'
db_password = '123'
while True:
username = input('please input your username >>>: ')
password = input('please input your password >>>: ')
if username == db_username and password == db_password:
print('登录成功')
while True:
cmd = input('please input your cmd >>>: ')
if cmd == 'q' or cmd == 'Q':
break
print('%s is runing' %cmd)
break
else:
print('登陆失败')
代码二：
db_username = 'syy'
db_password = '123'
flag = True
while flag:
username = input('please input your username >>>: ')
password = input('please input your password >>>: ')
if username == db_username and password == db_password:
print('登录成功')
while flag:
cmd = input('please input your cmd >>>: ')
if cmd == 'q' or cmd == 'Q':
flag = False
print('%s is runing' %cmd)
flag = False
else:
print('登陆失败')
限制用户登录错误的尝试次数，
1.用户尝试三次还不对的情况下直接结束程序。
2.用户尝试三次错误之后，提示用户是否继续尝试，如果用户输入y，那么再给用户三次机会，如果用户输入q，直接结束程序
代码一：
db_username = 'syy'
db_password = '123'
count = 1
while count < 4:
username = input('please input your username >>>: ')
password = input('please input your password >>>: ')
if username == db_username and password == db_password:
print('登录成功')
else:
print('登陆失败')
count+=1
else:
print('登录次数已用尽，程序结束')
代码二：
db_username = 'syy'
db_password = '123'
count = 1
while count < 4:
username = input('please input your username >>>: ')
password = input('please input your password >>>: ')
if username == db_username and password == db_password:
print('登录成功')
else:
print('登陆失败')
count+=1
else:
res = input('是否继续尝试>>>: ')
count2 = 1
while count2 < 4:
if res == 'y':
while count2 < 4:
username = input('please input your username >>>: ')
password = input('please input your password >>>: ')
if username == db_username and password == db_password:
print('登录成功')
else:
print('登陆失败')
count2 += 1
print('6次登录次数已用尽，程序结束')
elif res == 'q':
print('3次登录次数已用尽，程序结束')
else:
print('请输入y/q')
res = input('是否继续尝试>>>: ')
代码三：
db_username = 'syy'
db_password = '123'
n=1
while True:
if n == 4:
while True:
res = input('3次访问次数已用尽，是否要继续输入?(y/n)')
if res == 'y':
n = 1
break
elif res == 'n':
break
else:
print('请输入y/n')
username = input('please input your username >>>: ')
password = input('please input your password >>>: ')
if username == db_username and password ==password:
print('登录成功')
else:
print('登录失败')
n+=1
for循环
优点：
不依赖索引取值
在容器中取完值自动结束
整型、浮点型不能使用for循环直接取值，字符串、列表、字典可以使用for循环直接取值/key
语法一：
for 变量名 in 容器类型:
代码
语法二:
#break，结束整个循环
for 变量名 in 容器类型:
if 条件:
break
代码
语法三:
#continue，结束本次循环
for 变量名 in 容器类型:
if 条件:
continue
代码
语法四:
#break，结束整个循环，不会运行else中的代码块
for 变量名 in 容器类型:
if 条件:
break
代码
else:
代码
语法五:
#continue，结束本次循环，会运行else中的代码块
for 变量名 in 容器类型:
if 条件:
continue
代码
else:
代码
循环打印：
for i in range(1,10): #range()函数顾头不顾尾
print(i)
range()在python2与python3中的区别：
python2中range()就是一个列表
python2中的xrange()就是python3中的range()
python3中的range()本质上是一个迭代器，不会占用多余的内存
for循环的嵌套
打印99乘法表:
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
...
9*1=9 ... 9*9=81
代码:
for i in range(1,10):
for j in range(1,i+1):
print('%s*%s=%s'%(i,j,i*j),end=' ')
print()
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
#print(),打印出空行，相当于回车键
for i in range(1,10):
print()
#print(end=' ')，打印特殊符号，不换行
for i in range(1,10):
print(i,end='|')
#打印金字塔
#当前层级current_level 空格数 星号数
1 9 1
2 8 3
3 7 5
max_level = 10
for current_level in range(1,max_level+1):
for i in range(max_level-current_level):
print(' ',end='')
for j in range(current_level*2-1):
print('*',end='')
print()
*
***
*****
*******
*********
***********
*************
***************
*****************
*******************
循环索引取值
#while + 字符串
l = 'hello world'
n =0
while n < len(l):
print(l[n])
n+=1
#while + 列表
l = [1,4,7,2,5,8,3,6,9]
n =0
while n < len(l):
print(l[n])
n+=1
#while + 字典
#字典取值的2种方法，字典取值必须要知道键才能取值
a = {'name':'syy','age':18,'habby':'run'}
print(a['name'])
print(type(['name']))
print(a.get('name'))
print(type(['name']))
错误实例：
L = {'name':'syy','age':18,'habby':'run'}
# n = 0
# while n < len(L):
# print(L[n]) #字典中没有索引，所以不能使用索引取值，字典必须通过键取值
# n+=1
print(L[*])
#for + 字符串
l = 'hello world'
for i in l:
print(i)
#for + 列表
l = [1,4,7,2,5,8,3,6,9]
for i in l:
print(i)
#for + 字典
L = {'name':'syy','age':18,'habby':'run'}
for i in L:
print(i)
L = {'name': 'syy', 'age': 18, 'habby': 'run'}
for i in L:
print(i,L[i])
队列和堆栈
#队列,先进先出
x = []
x.append('first')
x.append('second')
x.append('third')
print(x.pop(0))
print(x.pop(0))
print(x.pop(0))
#堆栈，先进后出
x = []
x.append('first')
x.append('second')
x.append('third')
print(x.pop())
print(x.pop())
print(x.pop())