第二周总结

目录

• 数据类型
  • 数据类型之整型
    • 整型的内置方法及操作
  • 数据类型之浮点型
    • 浮点型的内置方法与操作
  • 数据类型之字符串型
    • 字符串的内置方法及操作
  • 基本数据类型之bool值
  • 基本数据类型之元组（tuple）
    • 元组内置方法与操作
  • 基本数据类型之集合（set）
    • 集合内置方法与操作
  • 基本数据类型之字典（dict）
    • 字典的内置方法与操作
    • 列表的内置方法与操作
• 用户交互
• 格式化输出
• 基本运算符
• 常用赋值符
• 逻辑运算符
• 成员运算符
• 身份运算符
• 垃圾回收机制
  • 1.引用计数
  • 2.标记清除
  • 3.分代回收
• 流程控制理论
  • 流程控制理论知识的三种分类
  • 流程控制必备知识
  • 分支结构
  • 循环结构
  • for循环
• range方法
• range实战案例
• 可变类型与不可变类型
  • python的可变和不可变数据类型：
• 字符编码理论
• 字符编码实操

数据类型

数据类型之整型

整型（int）：
	整型就是指各种整数，整型属于不可变数据类型，
语法结构：
	变量名 = 整数数值

整型的内置方法及操作

语法：
关键字	int()
	通过int(其他数据类型)可以将其他类型的数据类型转换为整型。
	int('代转换的数据')
eg：
	string_demo = '12345678'
	int(string_demo)
注意：字符字符串中转换的必须是纯数字，出现其他形式立即报错。
进制数转化：
语法：十进制转换为其他进制
	bin()	二进制
	oct()	八进制
	hex()	十六进制
语法：其他进制转换为十进制
	int(0b) 二进制转十进制
	int(0o)	八进制转十进制
	int(ox)	十六进制转十进制
eg：
	十进制转化其他进制
num = 368
a = bin(num)	二进制
print(a)
oct(num)		八进制
b = oct(num)
print(b)
hex(num)		十六进制
c = hex(num)
print(c)
	其他进制转换十进制
int(0b101110000)	 二进制数转十进制
int(0o560)			八进制数转十进制
int(0x170)			十六进制数转十进制

数据类型之浮点型

浮点型（float）：就是小数
 
语法结构：
	变量名 = 小数

浮点型的内置方法与操作

型转换：
	float(其他数据类型)
eg：
 
string_demo = '13.14' # 只能出现一个小数点
float(string_demo)
浮点型类型转换仅可以转换一个小数点的数据，若为多个小数点，那么直接报错

数据类型之字符串型

字符串（float）：
	由单个或者多个字符组成，写在单引号、双引号、三引号、三双引号之中。
语法结构：
	变量名 = '字符或者字符串'（上面哪四种引号都可以）

字符串的内置方法及操作

索引取值：

'''
索引取值的起始位置是0，超出范围的直接报错
	变量名[下标]
'''
str1 = '1234.567.ABC'
str1[0]
print(str1[0], type(str1))
# 下标为-1的值为字符串的最后一个字符
print(str1[-1])

切片操作以及改变切片的方向

'''
变量名[ : : ]	#第一个数字为起始位置，第二个为结束位置，第三个为步长
'''
str1 = '1234.567.ABC'
# 从下标为0的位置开始切取，（其实初始位置默认是0），可以不写
# 一直切取到下标为5的数据值前面的那个下标为4的数据值，只切取到下标5之前
# 2表示步长，隔一个取一个
a = str1[0:5:2]
# 输出的结果为原字符串，可以得知，字符串属于不可变数据类型
print(str1)
# 如果取赋值之后的变量名即可输出86.
print(a)
 
'''
切片操作默认是从左到右进行取值，想要改变方向，需要把步长设置为-1。不可以从负数取到正数（可以取到0）。
'''
str1 = '1234.567.ABC'
# 步长设置为-1才可以取到
a = str1[-1:-5:-1]
print(a)
 
# 如果冒号前后都不写值，默认全都要
a = str1[:]
print(a)
 
# 如果第一个冒号前面不写，默认值为0
a = str1[:5]
print(a)
 
# 如果第一个冒号后面不写，默认为字符串的总长度
 
#步长的默认值是1，表示每一个都取
print(str1[:5:])

统计字符串中字符的个数

# 字符串长度获取方法len()
print(len(str1))

移除字符串首尾指定的字符

'''
.strip() 可以移除字符串首尾的字符，可以指定，如果不指定，默认是移除首尾的空格，指定的话，可以移除相应的字符，也可以指定移除左边lstrip()，或者指定移除右边rstrip().
'''
# 移除前后的全部空格
str1 = '   1234.567.ABC   '
print(str1.strip())
 
# 移除前后的全部$符号
str2 = '$$$1234.567.ABC$$$'
print(str2.strip('$'))
 
# 删除首尾的12字符串
str2 = '123.8567.098.ABC.321'
print(str2.strip('12'))
 
# 移除左边的字符串
str3 = '$$$1234.567.ABC$$$'
print(str3.lstrip('$'))
 
# 移除右边的字符串
str3 = '$$$1234.567.ABC$$$'
print(str3.rstrip('$'))

切割字符串中指定的字符

'''
split()方法可以通过指定的字符将一个字符串类型的数据切割为一个列表
'''
str1 = 'name|age|addr'
str1.split('|')
 
# 将变量str1通过识别‘|’解压赋值给sex、name、age三个变量
str1 = 'man|Jason|eleven'
sex, name, age = str1.split('|')
print(age, type(age))
 
# 从左到右切割指定个数   split() 默认的就是从左边开始切割
str1 = 'name|sex|addr|age|hobby'
a = str1.split('|', maxsplit=2)
print(a)
 
# 从右到左切割指定个数  maxsplit=1 表示最大切割个数
str1 = 'name|sex|addr|age|hobby'
a = str1.rsplit('|', maxsplit=1)
print(a)

字符串格式化输出

#format方法1：等价于占位符
res = 'my name is {} my age is {}'.format('jason', 123)     # my name is jason my age is 123
print(res)
# format方法2：索引取值并支持反复使用
res = 'my name is {0} my age is {1}'.format('jason', 123)   # my name is jason my age is 123
print(res)
res = 'my name is {0} my age is {1} {0} {0} {1}'.format('jason', 123)             # my name is jason my age is 123 jason jason 123 # 可以把后面的看成元组
print(res)
# format方法3：占位符见名知意
res = 'my name is {name} my age is {age}'.format(name= 'jason', age=123)    # my name is jason my age is 123
print(res)
res = 'my name is {name} my age is {age} {name} {age} {name} '.format(name= 'jason', age=123)  # y name is jason my age is 123 jason 123 jason
print(res)
# format方法4：推荐使用
name = input('username>>>:')
age = input('age>>>:')
res = f'my name is {name} my age is {age}'    # my name is jason my age is 18
print(res)

字符串中的大小写互换

'''
大小写相关
res = 'hElLO WorlD 666'
print(res.upper())         # HELLO WORLD 666
print(res.lower())         # hello world 666
	变量名.upper()
	变量名.lower()
'''
res = 'hello world'
print(res.isupper())   # 判断字符串是否是纯大写  # False
print(res.islower())   # 判断字符串是否是纯小写  # True

应用

'''图片验证码:生成没有大小写统一的验证码 展示给用户看
    获取用户输入的验证码 将用户输入的验证码和当初产生的验证码统一转大写或者小写再比对
'''
code = '8Ja6Cc'
print('展示给用户看的图片验证码, code')
confirm_code =input('请输入验证码').strip()
if confirm_code.upper() == code.upper():
    print('验证码正确')
 
res = 'hello world'
print(res.isupper())   # 判断字符串是否是纯大写  # False
print(res.islower())   # 判断字符串是否是纯小写  # True

判断字符串中是否是纯数字

res = 'jason'
print(res.isdigit())      # False
res = '123'
print(res.isdigit())      # True
eg:
guess_age = input('guess_age>>>:').strip()
if guess_age.isdigit():
    guess_age = int(guess_age)
else:
    print('年龄都不知道怎么输吗???')

替换字符串中指定的内容

'''
replace(' ',' ') 括号内里前面引号里是需要替换的内容，前面引号里是替换的内容
'''
str = 'My name is Jason'.replace('Jason', 'tony')
print(str)
 
'''
可以从左向右按个数逐个进行替换指定个数
'''
res = 'my name is jason jason jason jason jason'
print(res.replace('jason', 'tony', 1))      # 只替换一个 my name is tony jason jason jason jason 从左往右替换指定个数内容

字符串的拼接

'''
直接使用加号拼接
'''
str1 = 'hello'
str2 = 'world'
str3 = str1 +' '+ str2
print(str3)
 
'''
'需要加入字符串'.列表
可以加入字符，然后该列表变为字符串
'''
ls = ['hello', 'world','hello', 'world']
ls1 = '|'.join(ls)
print(ls1, type(ls1))

统计指定字符出现的次数

res = 'hello world'
print(res.count('l'))       # 3

判断字符串的开头或者结尾(startwith)

res = 'jason say hello'
print(res.startswith('jason'))      # True
print(res.startswith('j'))          # True
print(res.startswith('jas'))        # True
print(res.startswith('a'))          # False
print(res.startswith('son'))        # False
print(res.startswith('say'))        # False
print(res.startswith('o'))          # False
print(res.startswith('llo'))        # False
print(res.startswith('hello'))       # False

基本数据类型之bool值

布尔值（bool）：
	 只有两个结果True、False，用来表示对错。
    默认为False的值：0、None、空字符串、空集合、空字典等
    布尔值的命名规范：is_delect、is_alive
语法结构：
	变量名 = True
	变量名 = False
eg:
    is_delect = False
    is_alive = True

基本数据类型之元组（tuple）

元组： 不可变序列的Python对象序列
	元组内的值不可随意改变
	语法结构：
    变量名 = (各种数据类型，各种数据类型)
eg：
	tuple_student = ('Jason', 'tom', 'tony', 'Maria')

元组内置方法与操作

1.类型转换
tuple()
支持for循环的数据类型都可以转换为元组
2.元组必须掌握的方法
t1 = (11, 22, 33, 44, 55, 66)
print(l1[2])# 1.索引取值
print(l1[2:4])# 2.切片操作
print(l1[0:5:2])# 3.间隔、方向
print(len(t1))  # 6    # 4.统计元组内数据值的个数
print(t1.count(11))# 5.统计元组内某个数据值出现的次数
print(t1.index(22))# 6.统计元组内指定数据值的索引值
 # 7.元组内如果只有一个数据值那么逗号不能少
# 8.元组内索引绑定的内存地址不能被修改(注意区分 可变与不可变)
#可变的：列表、集合、字典
#不可变的：数字、字符串、元组
# 9.元组不能新增或删除数据

基本数据类型之集合（set）

集合：集合和字典一样都是无序的
	集合内的数据是不可重复的
    语法结构：
    变量名 = {各种数据类型，各种数据类型}

集合内置方法与操作

set()
集合内数据必须是不可变类型(整型 浮点型 字符串 元组)
集合内数据也是无序的 没有索引的概念1类型转换
去重
去除集合内重复的数据值
 
    l2 = {11, 33, 44, 88, 99}
    l1 = set(l2)
    l2 = list(l1)
    print(l2)      # [33, 99, 88, 11, 44]
关系运算
&    共同的部分
-    独有的部分
|    全部的部分（和）
^    独有部分的和
eg:
 l1 = {11, 22, 33, 44, 55, 66} 
 l2 = {11, 33, 44, 88, 99}
  print(l1 & l2)  # 两个共同的数字
  print(l1 - l2)  # l1独有的数字
  print(l1 | l2)  # 两个共同的数字
  print(l1 ^ l2)  # 两个各自独有的数字
父级，子集
<   或者   >

基本数据类型之字典（dict）

字典（dict）：
	它用于存放具有映射关系的数据。 字典相当于保存了两组数据，其中一组数据是关键数据，被称为key；另一组数据可通过 key 来访问，被称为value。整体称之为键值对。
语法结构：
	变量名 = {'key': 数据值}

字典的内置方法与操作

1.类型转换
​ dict()
​ 字段转换一般不使用关键字，而是自己编写代码进行转化
2.字典掌握的方法
user = {
    'name':'zhangsan',
    'age': 18,
    'like':['ball','music','xiaoji']
}
print(user['name'])#zhangsan
print(user['aaa'])# zhi接报错
print(user.get('name'))#zhangsan
print(user.get('aaa'))#如果不存在k键就会返回None
print(user.get('aaa','111'))#如果不存在k键就会返回111
#3.修改值的数据
user['name']='lisi'#将name的值替换成list
#4.新增键值对
user['sex']='boy'#添加{'sex':'boy'}
#5.删除数据
del user['name']
a1=user.pop('age')
print(a1)#就会弹出age:18数据值
#6.统计字典中键值对的个数
print(len(user))#会输出user的键值个数
#7.字典三剑客
#用.keys方法一次性输出所有的键
print(user.keys())#一次性输出字典的所有的键
#用.value一次性输出所有值
print(user.value())#一次性输出所有值
#用.items()方法一次性获取字典中所有的键值对
print(user.items())#一次性获取字典的所有值dict_items([('name', 'zhangsan'), ('age', 18), ('like', ['ball', 'music', 'xiaoji'])])
for k,v in user():
#就等于
for i in user():
    k,v=i
#8.补充说明
user1={}
print(user1.fromkeys(['name','age','hobby'],(123)))#{'name': 123, 'age': 123, 'hobby': 123}
print(user1.fromkeys(['name','age','hobby'],[])#{'name': [], 'age': [], 'hobby': []}
user1['name'].append('jason')
user1['pwd'].append(10)
user1['hobby'].append('sing')
print(user1)
#{'name': ['jason', 10, 'sing'], 'pwd': ['jason', 10, 'sing'], 'hobby': ['jason', 10, 'sing']}
# 键存在则不修改 结果是键对应的值
print(res)  # {'name': [], 'pwd': [], 'hobby': []}
res = user_dict.setdefault('username','tony')
	print(user_dict, res)
    # jason', 'password': 123, 'hobby': ['read', 'music', 'run']} jason
# 存不存在则新增键值对 结果是新增的值
res = user_dict.setdefault('age',123)
	print(user_dict, res)
    # jason', 'password': 123, 'hobby': ['read', 'music', 'run'], 'age': 123} 123

列表的内置方法与操作

1.列表类型转化
关键字：
list
类型转换
能够被for循环的数据类型都能转换成列表
print(type(list(数据 )))
方法
l1=['123','123321','4564651','465136']
#1.索引取值
print(l1[0],type(l1[0]))
print(l1[-2])
#2.切片操作
print(l1[0:3])
#3.输出全部数列
print(l1[:])
print(l1[-4:-1])
#间隔数 方向 与字符串讲解一致
print(l1[::2])#间隔
#统计列表中数值的个数
print(len(l1))
l1[1] = 1111
print(l1)
#6.列表添加数据值
#6.1：尾部添加数据值
l1.append(12312313213)
print(l1)
l1.append(['jason','jianjian','lili'])
#6.2：任意位置插入数值
l1.insert(0,'aaa')
print(l1)
l1.insert(1,[12,12,13,45])
print(l1)
#6.3扩展列表 合并列表
a1=[11,22,33]
a2=[22,33,44]
print(a1+a2)#[11, 22, 33, 22, 33, 44]
a1.extend(a2)#[11, 22, 33, 22, 33, 44]
print(a1)
for i in a2:
    a1.append(i)
print(a1)#[11, 22, 33, 22, 33, 44]
#7.删除列表数据
#7.1通过删除关键字
del l1[0]
print(l1)
#7.2使用remove
l1.remove(121)
print(l1)
#7.3pop
l1.pop(3) # 括号内填写索引值
print(l1)
l1.pop()# 默认尾部弹出数据值
print(l1)
res = l1.pop(3)
print(res)  # 444
 res1 = l1.remove(444)
print(res1)  # None
#8.排序
ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
ss.sort()  # 默认是升序
print(ss)
ss.sort(reverse=True)
print(ss)  # 改为降序
#9.统计列表中某个数据值出现的次数
print(l1.count(111))
#10.颠倒列表顺序
l1.reverse()
print(l1)

用户交互

input # 获取用户输入
username = input('输入你的用户名')
password = input( '输入你的密码')
"""
	 1.先执行input获取用户输入
    2.将输入的数据绑定给变量名username
    3.以后在程序中就可以使用变量名反复调用用户数据
"""
input 获取的信息会成为字符串
输出内部信息
print
1.括号中即可以放数据又可以放变量名，支持多个中间用逗号隔开
2.print自带换行
换行符：\r\n \n 斜杠与字母组合到一起会产生特殊的含义
3.print也可以切换结束符
print（数据，end='默认是\n'）
python2中
input方法需要用户自己提前指定数据类型 写什么类型就是么类型一致 输入的统一处理成字符串
python2中
print方法有两种使用方式
print 数据值
print(数据值)

格式化输出

提前定义好一些内容，在需要的时候只需要局部修改
在程序中需要占位符：%s %d
info = '%s您好'
'''单个占位符'''
info = '%s您好'
print(info % 'leilei')
print('%s您好' % 'mingming')
print(info % ('lei1',))
print('%s您好' % ('lei2'))
''' 多个占位符'''
info2 ='姓名：%s 年龄：%d 爱好：%s'
print(info2 % ('leilei', 18, 'rap'))
q1 = info2 % ('leilei', 18, 'rap')
print(q1)
print(type(q1))
print('姓名：%s 年龄：%d 爱好：%s' % ('lei1', 16, 'sing'))
'''注意事项:有几个占位符就需要几个数据值'''
'''不同占位符的区别'''
demo1 = '%s您好 您本月的话费是%s 余额是%s'  # %s常见数据类型都支持
demo2 = '%d您好 您本月的话费是%d 余额是%d'  # %d只支持数字类型
print('%08d'% 123)  # 00000123生成8位数
print('%08d'% 1234324324)  # 1234324324多了即赋值的数值

基本运算符

+   -   *   /    %     //    **
  n = 10
  n += 1  # n = n + 1
  n -= 1  # n = n - 1
  n *= 1  # n = n * 1
  n /= 1  # n = n / 1
  n %= 1  # n = n % 1
  n //= 1  # n = n // 1
  n **= 1  # n = n ** 1
2.比较运算符
< > <= >= ==(等于号) !=(不等于)

常用赋值符

1.链式赋值
t1 = '01'
12 = t1
t3 = t2
# t1=t2=t3
2.交叉赋值
m = 100
y = 101
方法1：
z = m
m = y
y = z
print(m, y, z)
方法2：
m, y = y, m
print(m, y)
3.解压赋值
n_list = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
#低级写法
name1 = n_list[0]
name2 = n_list[1]
name3 = n_list[2]
name4 = n_list[3]
# 正常写法
name1, name2, name3, name4 = n_list
#解压赋值在使用的时候需要保证左边的变量名与右边的数值个数保持一致
#当需要解压的数据个数较多只需要其中几个是可以用
	 a, *b = n_list
    print(a)  # zhangsan
     print(b)  # ['lisi', 'wangwu', 'zhaoliu']
     a, c, *b = n_list
     print(a)
     print(c)
     print(b)  # ['wangwu', 'zhaoliu']
     a, *b, c = n_list
     print(a)  # zhangsan
     print(b)  # ['lisi', 'wangwu']
     print(c)  # zhaoliu
   # 当数据值不准备使用的时候 可以使用下划线作为变量名绑定
   a, *_, c = n_list

逻辑运算符

and(与) or（或） not（非）
print(1 < 10 and 666) # 666
print(1 < 10 and 2 > 1) # false
print(111 and 222) #222
and连接多个条件成立时结果才成立
or连接多个条件只有一个条件成立则成立
not 非

成员运算符

in判断个体在不在群体内

身份运算符

id()返回一串数字该数字可以看成内存地址
==判断数据值是否相同

垃圾回收机制

1.引用计数

1  name = 'jason'           # 'jason'被关联了一个变量名name，称之为引用计数为1
2  name1 = name             # 把name的内存地址给了name1，而name、name1都关联了'jason'，所以'jason'的引用计数为2
3 del name1                 # 解除'jason'和name1的关联，'jason'身上的引用计数变为1
当数据值身上的引用计数为0的时候    就会被垃圾回收机制当做垃圾回收掉
当数据值身上的引用计数不为0的时候  永远不会被垃圾回收机制回收

2.标记清除

为了解决循环引用的不足，python的底层不会单单只用引用计数器，引入了一个机制叫做标记清楚。主要针对循环引用问题。
height1 = [123, 321] # 引用计数为1
height2 = [111, 222] # 引用计数为1
height1.append(height2) #引用计数为2 height1 = [123, 321, 111, 222]
height2.append(height1)#引用计数为2 height1 = [ 111, 222 123, 321]
del height1 # 断开变量名height1与列表的关系
del height2 # 断开变量名height2与列表的关系
当内存达到临界值时，程序会自动停止，然后扫面程序中所有的数据，并且给只产生循环引用的数据打上标志之后一次性清楚。

3.分代回收

将第二个链表（可能存在循环引用的链表），维护成3个环状双向的链表：
0代： 0代中对象个数达到700个，扫描一次。
1代： 0代扫描10次，则1代扫描1次。
2代： 1代扫描10次，则2代扫描1次。
垃圾回收机制的频繁运行也会消耗各类资源，用0，1，2代分别对计数进行判断来处理数据价值。

流程控制理论

流程控制理论知识的三种分类

1、顺序结构
	按程序语句的自然顺序，自上到下，依次执行每条语句的程序
2、分支结构
        事物执行会根据条件的不同做出不同的执行策略。
3、循环结构
	根据条件是否成立，来判断是否循环执行代码块，叫做循环结构

流程控制必备知识

1.python中使用代码缩进来表示代码的从属关系。
2.并不是所有的代码都可以拥用缩进的子代码
3.如果有多行子代码属于同一夫代码，那么这些子代码需要保证相同的缩进量。
4.python中针对缩进量没有具体的要求，但是推荐4个空格。
5.在某一行代码需要编写子代码时，那么比这一行代码的结尾肯定要冒号。
6.相同缩进量的代码彼此之间平起平坐，按照顺序结构一次执行。

分支结构

1.单if分支结构
if 条件
  条件成立后才会被执行
 i = 5
if i < 10:
    print(i)
    print(i+1)
    print(i+2)   
2.if...else...分支结构
if 条件:
     	条件成立之后执行的子代码
	else:
      	条件不成立执行的子代码

3.if...elif...else分支结构
if 条件1：
	条件1执行的代码
 elif 条件2：
	条件1不成立条件2成立
 elif 条件3:
    条件1和条件2都不成立，条件3成立的子代码
 else:
    上述条件都不成立 执行的子代码

4.if嵌套使用
age = 28
height = 170
weight =110
is_beautiful = True
is_success = True
username = 'tony'
if username == 'tony':
    print('tony发现目标')
    if age < 30 and height > 160 and weight < 150 and is_beautiful:
        print('大妹子 手机掏出来 让我加微信')
        if is_success:
            print('吃饭 看电影 天黑了...')
        else:
            print('去你妹的 流氓')
    else:
         print('看电影太无聊')
else:
    print('癞蛤蟆')

循环结构

反复执行的代码
关键字while主要表达形式如下：
while 条件表达式：
	语句
与 if 语句相似，while 循环的条件表达式也无须括号，且表达式末尾必须添加冒号。当条件表达式计算结果为 True 时，执行下一行缩进的语句；若条件表达式计算结果为 False，则跳过该条语句继续向下执行。例如：
n = 10
sum = 0
i = 1
while i <= n:
    sum = sum + i
    i += 1
print("1 到 %d 之和为：%d" %(n,sum))
1.先判断条件是否成立
2.如果成立就生成循环体里面的代码
3.循环体执行完毕后再次回到条件判断处，判断条件是否成立，如果成立则会执行循环体内的代码。
按照上述的规律，直到条件不成立结束循环体内的代码。
关键字
break # 强制退出
continue # 跳过条件判断处
# continue 和 break 用法
i = 1
while i < 10:
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print i         # 输出双数2、4、6、8、10
 
i = 1
while 1:            # 循环条件为1必定成立
    print i         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break
1.死循环
在编程中，一个无法靠自身的控制终止的循环被称为死循环。
死循环会大量增加cpu的运算。
while 2:
    print('11111')
2.嵌套及全局标志位
所谓嵌套循环就是一个外循环的主体部分是一个内循环。内循环或外循环可以是任何类型，例如 while 循环或 for 循环。 例如，外部 for 循环可以包含一个 while 循环，反之亦然。外循环可以包含多个内循环。 循环链没有限制。
需要注意：
一个break只对他所在的那一层循环结束，并不会结束整个全部代码。
有while循环，想结束循环就要在每层while里写几个break来终止代码。用break太麻烦也可以用全局标识位，来进行对循环控制。
嵌套
user_age = 18
dl = 1
while 1:
    print('开始游戏')
    user_cage = input("请输入您猜的年龄")
    user_cage = int(user_cage)
    if user_cage > user_age:
        print("猜大了")
    elif user_cage < user_age:
        print("猜小了")
    else:
        print("恭喜你猜对了")
        break
全局标志位
定义一个计数器然后通过true和false来控制循环结构的执行和结束。
d1 = 1
while d1:
    user = input("输入你的用户名")
    password = input("输入你的密码")
    if user == '123' and password == '123':
        while d1:
            c1 = input('请输入是否继续')
            if c1 == 'q'
            	d1 = 0
              print('正在执行您的指令:%s' % c1)
    else:
            print('用户名或密码错误')
break和continue都是用来控制循环结构的，主要是停止循环。区别：break指的是终止、结束循环；continue指的是本次的循环，进入下一次的循环。

for循环

for 循环
1. 关键字in后面的序列指的是一组值，可能是数字，也可能是字符串。
2. 关键字for后面的变量就是依次取序列里的值，每取一次值就执行一次下面的代码块，直到序列里的值全取完。
特别注意：for那行语句最后用“：”结尾，下面的代码块必须缩进！
for循环特点
​ 1.擅长于遍历取值
​ 2.不需要结束条件，自动结束（比while使用简单）
for循环主要遍历的类型（常见：字符串、列表、元组、字典、集合）
name_list = ['jason', 'tony', 'tom', 'jack']
for i in name_list:
    print(i)
'''
for循环遍历字符串
'''
for i in 'hello word!':
	print(i)
'''
for遍历字典
	遍历出来，显示的字典的是k
'''
dic_info={'name': 'jason',  'age':'18','addr':'nanyang' }
for i in dic_info:
	print(i)
'''
for遍历集合
'''
set_age = {1,2,3,4,5,6}
for i in set_age:
	print(i)
'''
for遍历元组
'''
trup_name = ('tony', 'tom', 'sandy')
for i in trup_name:
	print(i)
for循环句法的命名：
1见名知意 eg:名字、性别
2如果遍历出来的数据没有具体含义可以用一些字母代替 eg:i、j、k等
for循环可以跟break和for连用
还可以跟else连用

range方法

range(范围)可以用在for循环中产生多个数字数据
for i in range(100):
    print(i)  # 即可输出0-99数据
for i in range(10, 20):
    print(i)  # 即可输出10到19的数据值
for i in range(10, 100, 2):
    print(i)  # 即可生成10到99的等差数列
python2和python3区别
1.print输出不同，在2中无须用将文本加括号在3中必须加括号
2.Python 2将小数点后面没有任何数字的数字视为整数，这可能会导致在除法期间出现意外结果。例如，如果在Python 2代码中输入表达式：3/2，则评估结果将为1，而不是你所期望的1.5。
这是因为Python 2会假设你希望除法的结果为整数，因此它将计算向下舍入到最接近的整数。为了获得结果1.5，你必须编写3.0 / 2.0来告诉Python，你希望它返回一个浮点数，即在结果中包含小数点后面的数字。
Python 3则会默认将3/2评估为1.5，这对于新程序员来说有更直观的感受。
3.range 在2中range()直接产生一个列表 内部含有多个数值xrange()
其实就是python3里面的range在python3中range()类似于一个工厂 不会占用太多的内存空间 要就生产

range实战案例

大数据是当代时代热门话题大部分网络爬虫是由python来编写代码的，可以使用python来获取想要的数据。
项目爬取博客圆的页码信息数据
y = 'https://www.cnblogs.com/#p%s'
for i in range(200):
    print(y % i)

可变类型与不可变类型

python的可变和不可变数据类型：

1.可变的：列表、集合、字典（可以进行更改，并且更改后物理地址不会发生改变）
2.不可变的：数字、字符串、元组（不可以进行更改，更改后就是一个新的对象了，物理地址发生了变化）
aa='bbaaabb'
bb=[11,22,33]
aa.strip('b')
print(aa) #bbaaabb
a1= bb.append(44)
print(bb)#[11,22,33,44]
print(a1)#none
#可变类型：数据值改变 内存地址不变
a=[11,22,33]
print(a)
print(id(a))
a.append(22)
print(a)
print(id(a))
#不可变类型：数据值改变 内存地址也改变
a2='aahdasdasdasdaa'
print(a2)
print(id(a2))
a2.strip('aa')
print(a2)
print(id(a2))

字符编码理论

1.字符编码只针对文本数据
2.计算机存储数据的本质是二进制，因为计算机只认识0和1，在和计算机交互的时候，用的是我们能够读懂的语言
3.字符编码的发展史：
一家独大
      计算机是美国人发明的，由于计算机值认识0和1，于是定义了字符编码，但是只记录了英文字符与数字之间的对应关系，于是有了ASCII码，内部只记录英文字符和数字之间的对应关系
群雄割据
       越来越多国家使用计算机之后，各个国家都开发了属于自己国家的字符编码
    中国：GBK编码，内部记录了中文字符，英文字符，和数字之间的对应关系，2bytes起步存储中文
    韩国：Euc_kr码，内部记录了韩文字符、英文字符与数字之间的对应关系。
    日本：shift_JTS码，内部记录了日文字符、英文字符与数字之间的对应关系。
.万国码：unicode，兼容各个国家的字符。原有的字符全部使用2bytes起步存储。
UTF家族，是针对unicode的优化版本，常用的是utf-8。英文1bytes存储，其它统一3bytes存储字符。
内存使用的是Unicode，硬盘使用utf8。
编码与解码
  编码：将人类可以读懂的字符按照指定的编码形式转换成计算机能够读懂的语言(数字)。简记：人类的字符转换成计算机的字符。关键字：encode.
  解码：将计算机能够读懂的语言按照指定的编码形式转换为人可以独懂得字符，关键字：decode

字符编码实操

1.针对乱码切换编码即可
2.编码与解码
	编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
        字符串.encode()
 	解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
        bytes类型数据.decode()
3.python2与python3差异
	python2默认的编码是ASCII
		1.文件头
        	# encoding:utf8
    	2.字符串前面加u
        	u'你好啊'
 	python3默认的编码是utf系列(unicode)