周总结

摘要：这一周，学习到了很多小知识点，也做了一些课后作业，虽然能自我完成作业，但是还是有小瑕疵，当遇到有个知识点我没有掌握，我还没参透里面的作用和效果，我就会百度查找相似的题目就会再做一下，直到我用自己的理解解出答案为止。对于我来说，写博客真的是一件很复杂的事情，耗时太长，我需要用一个下午到晚上的时间才能写完，我觉得还是用自己的语言去描述，会不会更快一点？作业的难度，老师很仁慈并不会让我们需要用一天时间去完成这个作业，可能前期是这样，没准过段时间，写博客的效率提上去了，随之作业难度也加大。

一、基本数据类型：

1.整型(int)
	本质：就是整数  int()
	内置方法：没有内置函数，就只是用于计算。
	数据类型转换： int(待转的数据)
		1.int 可以将纯整数的字符串转换成整型，且输出的类型都是 int类型。
		2.如果字符串里有字母，或者小数点，特殊符号，则都不能转，会报错。
		3.整型会直接将布尔值 True/False 直接转换成 1/0
	

进制数转换：
	1.进制数有4种。
		二进制、八进制、十进制、十六进制
	2.十进制转其他进制
		bin(十进制数据) => 二进制，bin 为二进制标识
		oct(十进制数据) => 八进制，oct 为八进制标识
		hex(十进制数据) => 十六进制，hex 为十六进制标识
	如果没有任何标识，则默认都是十进制。
	3.其他进制转十进制
		直接用int(其他进制数据) => 十进制数
		或者 直接用int(其他进制数据,n) => 十进制数(n为2,8,16)人为指定进制数。

2.浮点型(float)
	本质：小数 float()
	内置方法：没有内置函数，就只是用于计算。
	数据类型转换
		1.整型转换成浮点型，只需要后面添加小数点和0
		2.有字母不能转换成浮点型，不然报错。
		3.只能识别一个小数点，但不能识别多个小数点。不然会报错。
		4.布尔值转换成浮点型会有 True/ False 转换成 1.0/0.0

3.字符串/字符型(str)
	1.本质：由数字、字母、下划线组成的一串字符。
		有单引号/双引号/三引号构成。注意二三引号也可以用于注释，但左右没有赋值符号或者变量时就是注释，不然就是字符串。
	2.数据类型转换
		兼容所有数据类型的转换。
	3.内置方法
		3.1按索引取值
			正向取： s1[n] (n为阿拉伯数字,1)
			反向取： s1[m] (m为阿拉伯数字负数形式，-1为最右边的第一个数值)
			索引取值只能取值，不能绑定为其他数据值。
		3.2切片
			取出多个字符，切片数据默认都是从左到右的。
			正向切片（顾头不顾尾，前包含后不包含）
			反向切片（为负数，则从最右边第一个数-1开始取）
		3.3间隔/方向
			s1[x,y,z]  (x,y,z 均为阿拉伯数字，也可以为负数)
			当z = 2 时是代表步长为2，就是每取一个字符就中间隔一字符再取，默认1可以不用写。
			取出全部字符： s1[:]
		3.4统计字符串中字符的个数 len
		3.5移除字符串首尾两边的字符，中间字符不行。 strip
			注意：字符串里面一个空格也算一个字符
				  字符调用内置方法，不是改变原来数据，二三产生新的数据值。
		3.6按照指定的字符切割字符串，将指定的字符切除。 split
		3.7字符串大小写转换 lower/upper
			将字符串里的所有字母转换成小写或者大写。
		3.8字符串的格式化输出 {}  format
			方式一：等价于占位符%s====这里用{}来代替占位符，然后xxx.format('要替换的字符','要替换的字符','要替换的字符'....)
			方式二：索引取值，支持重复使用。
				res2 = 'my name is {0} my age is {1} {0} {1} {1} {1}'
				print(res2.format('xz', 18))
        #my name is xz my age is 18 xz 18 18 18
			方式三：按K取值（关键字取值），支持重复使用。
			 res3 = '{name} {name} {age} my name is {name} my age is {age}'
			  print(res3.format(name='xz', age=18))
        #xz xz 18 my name is xz my age is 18
			方式四:'f'
				先定义变量，简写f后面用变量名表示。
			name = 'xz'
			age = 18
			print(f'my name is {name} my age is {age} {name} {age}')
			#my name is xz my age is 18 xz 18
		3.9统计字符串中指定的字符出现的次数 count
		3.10判断字符串的开头或者结尾是不是指定的字符。
			判断开头:s1.startswith('xxx')
			判断结尾:s2.endswith('xxx')
		3.11字符串的替换 replace
			res.replace('xz', 'wyb', 1)，从左往右替换指定个数1
		3.12字符串的拼接 join
			注意：列表数据中必须是字符串类型，不然会报错。
		3.13判断字符串中是否全为纯数字 isdigit
			如果全为纯数字则返回值为 True
			如果不是纯数字则返回为 False
		3.14查找某个字符对应的索引值  index
			index 查找索引，如果没有元素，报错
			find 查找索引，如果没有，则会返回为-1，False
		3.15正文
			如果字符串是标题化的，则见(title())则返回为True，不然返回为False。
			print(res.capitalize())  内容第一个字母为大写
			# My name is xz

4.列表(list)
	1.本质：list[1,2,3]。能存储多个数据且方便获取整体或局部数据。用中括号包含多个数据，且数据间用逗号间隔，数据值可以为任意的数据类型。
	2.索引取值，数字的起始位置从0开始数，生活是从1开始数。
	3.遇到复杂结构的构造结构，我们要先学会先拆后找到具体数据的位置。
	4.数据类型转换：
		列表只能转换字典和字符串，不能转换整型和浮点型。
		所以能够被for循环的数据类型都可以转换成列表。
	取值：
		4.1.索引取值：[0]为列表的第一个数。参数为正数，则正向从左往右开始取值。为负数，则从右往左数第一个数为-1。
		4.2.切片操作：[:] 冒号左边为从左开始取值的位置，冒号右边是从左往右最后一个位置，且遵循左包含右不包含。负数代表从右往左取值。
		4.3.间隔
			[::m]两个冒号后面的参数代表每隔 m-1 一个数取一个值。
		4.4.统计列表中数据值的个数。
			len（），统计列表中有多少个数据值。
	5.内置函数
		5.1.count():用来统计指定的成员在列表中出现的个数。
		5.2.index()返回该元素的索引值。
			注意：返回该元素的索引值是该元素在列表中第一次出现的位置。我们也能查询成员在特定位置范围内出现的索引值，eg:index(menber,m,n),表示menber在第m-1到n-1的位置。
		5.3.reverse():该列表元素前后颠倒。
		5.4.sort():将元素从小到大排序，如果想从大到小则可以与reverse()搭配使用。eg：list.sort(reverse = True)
		5.5.append():向列表中添加一个成员。 
		list.append(2)
		list.append('8')
			注意：1.一次只能添加一个成员，并且只能添加在列表末尾。2.可以添加字符串类型。
		5.6.exend():方法向列表中添加成员，并且是参数，可以为列表扩展列表。
			意思是exend后面是列表时，就会多加的列表里的成员到要添加的列表的后面
			如果exend后面跟字符串，则就会一个个字符拆开后依次再加入到列表后面。
			如果想让字符串完整的加入列表，则需要用列表的形式来添加。
		5.7.insert():特定位置添加成员。
			两个参数，insert（m,member）,在索引为m（也就是第m+1的位置进行添加）。
			注意:因为是两个参数，索引多加一个参数就会造成错误。
		5.8.remove():从列表中删除指定成员。
			注意:列表中有多个重复成员时，一次只能删第一个。
		5.9.del:用索引进行删除， del list [m] 删除列表第m-1 的数据值。
		5.10.pop{}:将指定位置的元素取出来，并删除，也就是说有返回值。删除的数据，返回出来就是已经删除后的列表。
            >>> list1 = [123, 456, 789]
            >>> list1
            [123, 456, 789]
            >>> b = list1.pop(1)
            >>> b
            456
            >>> list1
            [123, 789]

5.字典(dict)
	1.本质：存储多个数据值，且方便获取，数据间用逗号个开，用大括号包含，数据值形式是K：V键值对。
		K是对V具有描述性性质的信息。
		V的真实的数据值信息，V可以为任意的数据类型。
		为什么按K取值，因为字典是无序性的所以不支持索引取值。
		如果K不存在时，字典中没有K这个数据，则会报错。
		

6.布尔值(bool)
	本质：判断事物的可行性。
	两种状态。  True/False
	命名规律：以is开头
	在实际项目中数据库存储数据的特征，用一个字段来表示数据是否删除。
	没有内置函数。
	

7.元组(tuple)
	7.1.本质：被称为不可改变的列表，用个小括号来包含多数据值，是一个元组是安全的有序容器。
	eg：tuple1 = (1, 2, 3)
	用索引取值。
	list1[0] = 'w' # 打印出[w,  2,  3]

	tuple[0] = 'w' # 打印会出错。
	7.2.数据类型转换：可以将列表转换成元组，但是数据值不能修改。
	
	7.3.内置函数：
		7.3.1 len()计算元组元素个数。
		7.3.2 max()返回元组中元素最大值。
		7.3.3 min()返回元组中元素最小值。
		7.3.4 tuple(列表)，将列表转换成元组。
		>>> l1 = ['xx',1,2,'ww']
		>>> l1
		['xx', 1, 2, 'ww']
		>>> t1 = tuple(l1)
		>>> t1
		('xx', 1, 2, 'ww')
	

8.集合(set)
	8.1.本质：集合用于去重和关系运算，重复元素在set自动会被过滤掉。
(去除重复的部分，判断两个集合间的关系)
	用大括号包含多个数据值，符号和字典一样，但是内部结构不一样。类似dict，是一组key的集合，不存储value
	8.2.定义空集合是不一样的。
	不能直接用 set = {},这样返回的数据类型是字符串型，索引需要加个set才能表示是集合的空集合。eg：s = set()。
	8.3数据类型转换：
		8.3.1 列表（list）转换成集合（set）
			ll = [1,2,3,4,5]
                        s1 = set(ll)           
                        print(s1)               #{1, 2, 3, 4, 5}
                        print(type(s1))         #
		8.3.2 元组（tuple）转换成集合（set）
                        2 = (1,2,3,4,3,2)
                        s2 = set(t2)
                        print(s2)               #{1, 2, 3, 4}
                        print(type(s2))         #

	8.4内置函数：
              8.4.1 set.add()元素的添加。
				s4 = set([1,2,3,4,5])
				s4.add(6)                  #{1, 2, 3, 4, 5, 6}
				s4.add(3)                  #可以添加重复的，但是不会有效果
				#s4.add([7,8,9])           #报错 不能以列表的形式添加。
				s4.add((7,8,9))            #{1, 2, 3, 4, 5, 6, (7, 8, 9)}
				#s4.add({1:"a"})           #报错 不能以字典的形式添加。
				print(s4)
              8.4.2 set.update(列表，元组，字符串)
			任何数据类型都是以最小单位的形式插入。先拆后一个个放。
				s5 = set([1,2,3,4,5])
				s5.update([6,7,8])          #{1, 2, 3, 4, 5, 6, 7, 8}

				s5 = set([1,2,3,4,5])
				s5.update((9,10))           #{1, 2, 3, 4, 5, 9, 10}

				s5 = set([1,2,3,4,5])
				s5.update("luck")           #{1, 2, 3, 4, 5, 'c', 'k', 'u', 'l'}

				s5 = set([1,2,3,4,5])
				s5.update("never","luck")   #{'u', 1, 2, 3, 4, 5, 'k', 'l', 'n', 'r', 'v', 'c', 'e'}
              8.4.3 set.remove()删除指定元素。
				s6 = set([1,2,3,4,5])
				s6.remove(3) 
				print(s6)                    #{1, 2, 4, 5}
              8.4.4 遍历
				s7 = set("hello")
				for i in s7:
					print(i)
				'''
				输出：
				h
				o
				e
				l
				'''
              8.4.5 set 没有索引。
				s7 = set("money")
				for index, data in enumerate(s7):
					print(index, data)
				'''
				0 y
				1 n
				2 o
				3 e
				4 m
				'''
			 #set没有索引
#print((s7[3]))#会报错
			会出现：TypeError: 'set' object is not subscriptable
			 
              8.4.6 交集 &
				s8 = set([1,2,3])
				s9 = set([2,3,4])

				a1 = s8 & s9             #交集
				print(a1)                #{2, 3}
				print(type(a1))          #
			8.4.7 并集 |
				s8 = set([1,2,3])
				s9 = set([2,3,4])

				a2 = s8 | s9             #并集
				print(a2)                #{1, 2, 3, 4}
				print(type(a2))          #

二、与用户交互

1.输入：外界向计算机传递信息。
 name = input( "输入信息：")
 	注意:input获取用户的所有数据类型都会转化成字符串（str）类型。
	所以我们要进行强制类型转换，eg:
	num = input('输入数字：')
	num = int(num)
	我们也能颖内置函数来判断字符串类型是否转化成数字，num.isdigit(),返回类型是 True/False。
	
2.输出：计算机向外界传递信息。
print('xxx')
print("xxx")
print('''xxxx''')
都输出，但是三引号作用是多行输出。
可以一次性打印多行数据值。
指定参数  end='\r\n'  表示换行符。

3.输入和输出在python2和python3的区别：
	1.输入：
		python3中input('xxx')，无论什么数据类型都会转换成字符串类型。
		python2中input('xxx')，不改变任何数据类型。
		但是pythoon2可以加上一个raw_input('xxx')这样输出就相当于Python3的input。
	2.输出：
		print（）在python3中只有一种输出，但是在python2中有两种输出形式，一种python 另一种python(),一种加括号一种不加括号。但是功能都是一样的。


4.内置函数range在python2和python3中的区别：
		python3中的range得出结果是一个迭代器而不是一个列表。如果想要转化为列表对象则需要再使用list方法进行转化。
			>>> range(3)
			range(0, 3)
			
			range(0, 3)
			>>> list1 = list(l)
			>>> list1
			[0, 1, 2]
		python2中range得到是一个具体的列表，列表对象所拥有的方法，range方法生成的结果对象都可以直接使用。
			>>> range(3)
			[0, 1, 2]
		如果想让python2得到相当于python3的迭代器，则需要加一个xrange();
			>>> xrange(3)
			xrange(3)
			>>> list1 = xrange(1,3)
			>>> list1
			xrange(1, 3)
>>>

三、格式化输出

	1.就是准备一个文本，然后将文本里的一些内容替换。
	2.1.%s：支持所有数据类型的替换。
		info1 = "你好，%s，今天是你%s生日"
		print(info1 % ('xx',18))
		print("你好，%s，今天是你%s生日"%('xx',18))
	2.2.%d：只支持数字占位。
		使用方法和%s一样，但是%d受限制，只支持数字占位。
		产生固定位数的数据。
			print('%05d',23)  # 00023
			固定规定为5位数，不够需在前面补0

四、运算符

1.算数运算符
		加   +
		减   -
		乘   *
		除   /
		整除  //
		取模  %
		幂指数 **
2.算数运算符运算简写
		算数运算的简写：
    x = x + 10 可写成  x + = 10
    x = x - 10 可写成  x - = 10
    x = x * 10 可写成  x * = 10
    x = x / 10 可写成  x / = 10

2.比较运算符
		== 等于
		！=不等于

3.逻辑运算符
	1.and 与
		链接多个条件必须都成立结果才能成立。
	2.or 或
		连接多个条件有一个成立结果就成立。
	3.not 非
		条件取反。
	三者混合使用，需要加个括号来表示优先级，不然会出错。
	注意:实质上还是有优先级区分的
		() > not > and > or 

	4.字符串中数字比较大小是按照各个字符比较，就是位置从左往右一一比较。前面的数较大，则返回结果就是前面较大字符的字符串大于后者。

	5.
		5.1and的链接多个条件时都是成立，但是里面有一个具体的值，则结果为具体值。
		5.2.and链接条件的结果最终取决于后面的，最后的值是明确的数据值，则直接返回该数据值。
		5.3.and链接多个条件要一个个往后看，是否有不符合条件的，没有则返回为True，有具体数据值，则返回为该具体数据值。

	6.
		6.1.or 链接多个条件只要其中一个成立则结果成立。
		6.2.or 链接多个条件的判断是取决于前面的条件是否成立，前面是表达式且成立，则返回结果为True，无论后面是数据值还是True都不影响。
		6.3.or 链接多个条件要是从前往后看，是否有条件成立的，没有则返回为False，有具体数据值，则返回为该具体数据值
    

4.成员运算符
	4.1.in 表示在...之内
		如果在指定的序列中找到值返回 True，否则返回 False。 
	4.2.not 表示不在...之内
		如果在指定的序列中没有找到值返回 True，否则返回 False。

	4.3.列表在做成员运算的时候最小单位是整个数据值，不能拆分合并。
	4.4.字符串在做成员运算的时候最小单位是单个字符，可以增加字符个数。
	4.5.字典在做成员运算的时候只有K会参与运算，V不能暴露在外界。
5.身份运算符
	5.1.is 判断数据值内存地址是否一样
	5.2.== 判断数据值是否一致
	5.3.id() 该数据值会返回一串数字，相当于内存地址。
	5.4.注意:数据值相等，但是内存地址可能不一样。因为cpu每次向内存申请位置都是随机的。
	内存地址一样，数据值就相等，对于单次程序是这样。
	5.5.python具有内存优化的功能。
		python对于数量小且经常使用的数据就会做内存优化会建一个“小整数池”。还有一些IDE软件也能做更多优化处理。比如直接用解释器运行上述，则每次CPU访问内存地都不一样。

赋值符

1.链式赋值
三个或多个变量绑定相同的数据值。
		x = 10
		x = y = z
2.交叉赋值
如果想让x绑定y绑定的数据值，让y帮忙绑定x的数据值。
	x = 1
	y = 2
	方式一：（用中间变量）
        t = x
        x = y
        y = t
       print(x,y)
操作说明：
      1.首先数据值1绑定给x，数据值100绑定给y。
      2.t为变量与变量x绑定，x赋值给t，t为10.
      3.x与y绑定，x与原来的数据值1解绑，x为2。
      4.y与t绑定，y与原来的数据值2解绑，y为1。
总的来说只是利用中间变量t，来达到x与y相互交换数据值。
   
   方式二：（用交叉赋值）
        x, y = y, x
       print(x,y)
	简化了代码
3.解压赋值
	赋值符号左边的变量至少要两个以上才行。
	必须保证左边变量名和右边数据值要个数一致。

特殊情况，就是多个数据值绑定有限的变量名时，我们用*。
	>>> l1 = [1,2,3,4,5,6]
	>>> a,b,*c,d = l1
	>>> a
	1
	>>> b
	2
	>>> c
	[3, 4, 5]
	>>> d
	6
解压赋值会会自动将多余是数据值成列表赋值给带*后面的变名。

python缩进的作用

1.表示从属关系
	缩进代码能不能运行取决于上面有没有父代码。
2.缩进量无要求，但是为了美观可以缩进相同的缩进量。
3.并不是所有代码都可以拥有子代码，要明确父代码是哪些，是不是可以拥有子代码的权限。
	if  else  elif  中，elif和else不能单独使用需要和if一起使用才行。
	且 if else  elif 都在同一层次。
4.同属于一个父代码的多行子代码应该保证相同的缩进量，
	如果代码缩进了，应该往上找一个缩进量比其还小的缩进量的父代码，如果这父代码拥有子代码的权限，则不会报错。
5.相同缩进的代码没有主次之分，都是按照顺序依次执行。

五、流程控制

1.顺序结构
从上到下的执行，程序一般都是这种顺序执行的。
2.分支结构
根据条件的不同执行不同的代码
	1.if
		单if分支：
			if 条件 :
			  (条件成立执行代码)
			①条件可以是布尔值也可以是表达式。②条件是一个也可以用逻辑运算符链接的条件。
			if 条件1 :
			  (条件1成立执行代码)
			  if 条件2 ：
			    (条件2成立执行代码)
		这是if的嵌套。
		if...else 分支
			if 条件：
				(条件成立之后执行---子代码)
			else:
			   (条件不成立执行----子代码)
		3.if...elif...else分支
			if 条件1：
			   (条件1成立执行---子代码)
			elif 条件2：
			    (条件1成立执行---子代码)
			elif 条件3：
				(条件2成立执行---子代码)
			elif：
				 (上述所有的条件都不成立执行的代码)
	注意：f elif else 三者连用，永远只会走一个分支
		 elif 和 else都是不能单独使用 必须结合if。

3.循环结构
根据条件的判断决定是否一直执行操作。

1.while循环
while 条件：
   （ 条件成立后执行的子代码）
   
具体流程：
1.先判断while后面条件是否成立，如果成立则执行子代码
2.子代码运行后，再次回到while后面的条件判断，判断条件是否成立。
3.如果条件成立则有执行子代码，子代码运行完成后有返回到while条件判断。
4.如此反复执行，直到while后面条件判断不成立则结束循环。



	* 计数器 count
	上述循环，我们可以设置一个计数器来结束循环。设置一个循环的次数，当达到循环次数后就结束循环。
	eg：
		count = 1
		while count < 11:
			print('num:',count)
			count += 1
    '''
        num: 1
        num: 2
        num: 3
        num: 4
        num: 5
        num: 6
        num: 7
        num: 8
        num: 9
        num: 10
      '''
	 我们也可以用关键字break和continue来强制结束循环。
	 
	 
	 
	** while...break
	一个break只能结束在它所在的循环体代码。
	while True:
	print('1')
	while True:
		print('2')
		break  #①
	break #②
	注意：
		无①无②，则结果就为一层“1”，剩下无限循环“2”。
		有①无②，则结果就为一层“1”和一层“2”这样无限循环。
		有①有②，则结果就只有一层“1”和一层“2”。
		
		
		
	** while...continue
	就是跳过本次循环，接着下一次循环。
	while True:
		print(1)
		while True:
			print(3)
			continue  #①
		continue   #②
	1.如果没有位置①代码，则结果是 1 3 3 3 ...
	循环一直在子子代码的小循环体内。
	2.如果只有位置①的代码，则结果是 1 3 3 3 3...
	3.如果都有位置①和位置②的代码，则结果是 1 3 3 3 3 ...
	
	
	
	** while...else
		count = 1
		while count <5:
			print("num", count)
			if count == 3:
					break
			count += 1
		else:
			print("end")
    
	1.else 是等 while 后面的条件正常结束后才执行。
	2.如果碰上break后，强制结束执行，就不会执行else的子代码。
	3.如果将 else: 去掉，将 print与 while对齐，也会打印出结束循环的效果。但是有没有break都打印。
	
	

2.for循环
for 变量名 in 可迭代对象：
        （for 循环体代码）
	可迭代对象有字符串，列表，字典，元组，集合。
	2.1for  i in（列表）：
		打印出列表最小单位为数据值的整体，不能拆分合并。
		索引取值，将列表的数据值按顺序打印。
	2.2for  i in（字典）：
		因为按K取值，所以循环打印出的结果是K值。
		
	2.3for  i in（字符串）：
		按顺序打印出一个个单字符。
	2.4for  i in（元组）：
		与列表一样，利用索引，取出单个数据值。
	2.5for  i in（集合）：
		索引取值，取出整个数据值。

	2.6for i in range（）：
	如果要遍历数字序列，可以使用内置range()函数，它会生成数列。
	相当于while里的计数器。
		2.6.1for in range（m）
		括号内只有一个数字，那么就是从0开始到m-1结束。
		2.6.2for i in range（m,n）
		括号内有两个数字,第一个是起始位置m(包含) 第二个是终止位置n(不包含)
		2.6.3for i in range(m,n,z)
		括号内有三个数字m,n,z。z是数据的间隔数(相当于等差数列)
	2.7 for +break/continue/else
		2.7.1：break表示结束所在的那一层 for循环。
		2.7.2：continue表示结束所在的那一次for循环，直接开始下一次循环
		2.7.3：else配合 for一起使用。
当 for循环结束的情况下，循环体结束之后运行 else子代码。

	注意：当for 循环到列表没有元素可以循环时会自动结束循环的。

3.死循环与全局标志位
1.死循环
count = 10
while True:
    count *= 10 
这是一串死循环的代码，它能使cpu一直在高速运行，长时间这样使电脑发热。最好先避免死循环的发生。
while True:
    name = input('name>>>:')  
计算机需要获取用户的信息，即使在循环中，但是计算机还是有时间去等待，并非高速运行。
2.全局标志位(可以不用)
flag = True
while flag:
    print(1)
    while flag:
        print(3)
            flag = False
在面对 while 里面嵌套多个 while中，如果不想多个 break来结束各个循环体，我们可以采用全局标志来代替多个break的使用，可以改变循环体执行和死循环。这只是简化的代码。