'''
	运算符：
		赋值运算符：
				+=
				-=
				/=
				*=
				%=
				//=
				**=
	
		算术运算符：
				+  数字->求和，字符—>拼接 	False = 0		True = 1
				- 
				* 
				/ 
				%（取余） 
				//(整除) 
				**（幂运算）
				
				# 案列：求三位数的个位，十位，百位

                        a1 = int(input("请输入一个三位数："))
                        b = a1 // 100
                        s = a1 // 10 % 10
                        g = a1 %10
                        print(f"百位是{b},十位是：{s},个位是{g}")
                        
                        
         关系运算符：  结果：True False
         		  > 
         		  <
         		  >=
         		  <=
         		  ==
         		  !=
         		  is
         		  
         		  
         逻辑运算符： 
         		 not ： 非 
         		 and : 与 并且 		数字比较时，两边均非0，打印右边的数字的值，若含有0，即打印0，  	非零即真
         		 or： 或者				...................打印左边的数字的值，含有一个0，打印非0的值， 两个0，打印0
			
				eg:优先级顺序：从上到下


		强制转换：
            str -> int   整数可以，带小数点会报错
            bool -> int  True = 1  False = 0
            bool  -> float      1.0        0.0
            bool  -> str        True       False
            
            
		进制转换：
    		bin()  二进制转换 	oct() 八进制转换		int()十进制转换  hex() 十六进制转换
    		负数二进制 ： 算出正数的二进制->取反（0—>1,1->0)-> 加1 == 原码->反码->补码
    					最高位为1为负数，为0为正数		eg:1111 0111 负数	
    		一个字节Byte 有8个 二进制位bit
    		二进制：0~1		0b... 	十进制转二进制：除2取余	二进制转八进制：三位一组分割，不足补0		
    								二进制转十六进制：四位一组分割，不足补0	 
    		八进制：0~7		0O..    十进制转八进制：除8取余	
    		十进制：0~9     
    		十六进制：0~9 a~f	0x... 	十六进制转二进制：
    		
    		
    	位运算：
    		&: 与 	1为真，0为  同and
    		|：或		同 or
    		^：异或	相同为 0 不同为1
    		~：取反
    		<<：左移	eg: n1 = 0111 1110  n1 << 2(左移两位) -> 1111 1000
    					eg: n2 = 26   n2 << 4(左移四位) -> 26*(2**4)	左移数字变大
     		>>: 右移	同上  eg: n2 = 26   n2 >> 4(右移移四位) -> 26/(2**4)	左移数字变大
     		
     	运算符的优先级：
     		
    条件语句：
    		格式： 
    			1. if 条件语句：
    					执行语句
    			2. if 条件语句:
    					执行语句
    				else:
    					执行语句
    			3. if 条件语句1:
    					执行语句
    			   elif 条件语句2:
    			   .....
    			   else:
    					执行语句
             if语句嵌套
    循环语句：
    		while循环：
    				格式：
    					while 条件：
    							执行语句
    				过程：判断条件是否为真，执行代码,直到条件为假，停止执行
    				
    			# 案例：累加-> 求1~100的和
                    sum = 0
                    i = 1
                    while i <=100:
                        sum += i
                        i += 1
                        print(sum)
            break 和 continue
            	break:结束循环
            	continue:跳过当前循环
            
            for循环：
            	格式：
            		for 变量 in 可迭代的东西(如：字符串可迭代）：
            			执行语句
            			
            		把 可迭代的东西中的每一项内容拿出来，挨个赋值给变量，每一次赋值执行一次循环语句
            				
            	for循环想要计数，需要借助range()函数
            		range(10): 从0计数到9，左闭右开
            		range(3,10):3~9 	左闭右开
            		range(3,10,2):3,5,7,9  ->从3~9每隔两位输出
                        
	
    基础数据类型：
    		int float bool
    		str: 字符串
    		list: 列表
    		tuple: 元组
    		set: 集合
    		dict: 字典
    		bytes: 字节
    		
    		
    	bool:
    		非零即真，非空即真
    		
    	字符串：
    		字符串格式化：
    					%s ：字符串占位
    					%d ： 整数占位
    					%f ： 小数占位
    			eg:
    				name = "雨地里溜达"
                    age = 18
                    hobby = "打羽毛球"
                    
					i0 = "我的名字是%s" % name 		# 当数据只有一项时，可以省略不写括号()
                    i = "我的名字是%s,年龄%d，爱好是%s" % (name,age,hobby)
                    i1 = "我的名字是{},年龄{}，爱好是{}".format(name,age,hobby) 
                    i2 = f"我的名字是{name},年龄{age}，爱好是{hobby}"
    		
    		字符串的索引和切片：
    				索引：按照位置提取元素 	# 索引超出范围会报错
    				切片：从一个字符串中提取一部分内容	s[start:end:step] 左闭右开end取不到 每step(步长)个元素出来一个						  元素，若为负数，从右往左切
    					eg：
    						s = "我喜欢羽毛球和Python"
    				  索引   print(s[2]) 	# 结果 ： 欢
                      切片   print(s[3:6])  # 结果：  羽毛球   
                    		print(s[0:6]) == print(s[:6])  # 如果从头开始，0可以省略
                    		print(s[2:12]) == print(s[2:]) # 如果到末尾结束，可以不写末尾
                    		print(s[:])  # 左右两边都空白，表示从头切到尾
                    		print(s[-3:-1]) # 结果：ho	从左往右
                    		print(s[-1:-3]) # 结果为空，从左往右 -1切不到-3
                    		print(s[::-2])  #结果 ：nhy和毛欢我
                    		s1 = "我爱你"
                    		print(s1[::-1])  # 结果：你爱我
           
           字符串的常规操作：
           			字符串是不可变的数据类型
           			字符串的操作一般不会对原字符串产生影响，一般都是返回一个新的字符串
           			
           		1. 字符串的大小写转换：
                		
                	    capitalize() -> 首字母大写
                		title()	-> 将每个单词的首字母大写
                		lower() -> 将每个单词都变成小写字母		#对于处理某些国外验证码会出错，建议用upper()
                		upper（） -> 将每个字母都变成大写		
                	
                	eg:  应用： 验证码案列
                		verify_code = "xdY2"
                        user_code = input(f"请输入验证码({verify_code}):")
                        if verify_code.upper() == user_code.upper():
                            print("登陆成功！")
                        else:
                            print("登录失败！")
                         
                 2. 字符串的切割和替换
                 
                 		stripe() -> 去除字符串左右两端(空格,\n,\t) 
                 		
                 	eg: 应用：用户登录案列
                 		userName = input("请输入用户名：").strip()
                        passWord = input("请输入密码：").strip()
                        if userName == "admin" :
                            if passWord == "abc123":
                                print('登陆成功！')
                            else:
                                print("密码错误！")
                        else:
                            print("用户名错误！")
                            
                        
                      字符串的替换：
                        replace(old,new)  -> 将old替换成new  		# 应用：网络爬虫中 url空格，空白的替换 
                        
                      字符串的切割：  
                        splite(切割字符)  -> 返回的是个列表 用什么切，就会损失什么
                        
                     eg:
                     	s = "python_java_c++_javascript"
                        lst = s.split("_")
                        print(lst)
                        结果： ['python', 'java', 'c++', 'javascript']
                        
                 3. 字符串的查找和判断
                 
                 	find() -> 若存在，返回的是第一个字符的索引，若不存在，返回-1
                 	index() -> 若存在，返回的是第一个字符的索引，若不存在，程序报错  
                 	in 的用法：
                 			print("xxx" in s) -> 若s中存在xxx,返回True, 不存在返回False
                 			print("xxx" not in s) -> 若s中存在xxx,返回False, 不存在返回True
                 	startswith("x") -> 判断是否以x开头
                 	endswith("x") -> 判断是否以x结尾
                 	isdigit() -> 判断是否是整数
                 	
                 4. 补充
                 	
                 	len() -> 返回长度	eg； print(len("hellow"))
                 	join() -> 与split() 作用相反 字符串拼接
                  eg:
                  	 lst = ['python', 'java', 'c++', 'javascript']
                  	 print("_".join(lst))
                  	 结果：python_java_c++_javascript

                 5.	总结
                 	1. f"{变量}"  格式化一个字符串
                 	2. 索引和切片：
                 			索引：从0开始的，[]
                 			切片：s[start:end:step], end永远取不到
                 	3. 相关操作：
                 		字符串操作对原字符串是不发生改变的
                 		1. upper() 将字符串都变成大写
                 		2. strip() 去掉字符串左右两端的(空格,\t,\n)
                 		3. replace() 字符串的替换
                 		4. split() 字符串的切割
                 		5. join() 字符串的拼接
                 		6. len() 返回长度(内置函数->和input,print一样直接用)
                 		7. startswith() 判断字符串是否以x开头
                 		
                 		字符串的循环和遍历：
                 			for c in s:
                 				print(c)  # 打印字符串中的每一个字符
                 				
                 		关于in的用法:
                 			1. 判断xxx是否在xxxx中
                 			2. for 循环
                 	
                 		
      列表：
      		格式： a = ["b","c","d",["e",["f"]]]
      		特性：
      		 	1. 索引和切片 和字符串相同 
      		 	2. for循环  和字符串相同 
      		 	3. len(lst) 拿到列表长度
      		重要操作：增删改查
      		  增：
      		  
      		  	append() -> 追加
      		  	insert(x,"xx") -> 在索引x的地方插入xx
      		  	extend() -> 批量添加
      		  	
      		  eg：
                    lst = ["数二","英二","政治"]
                    lst.append("数据结构")
                    print(lst)
                    lst.insert(4,"计算机组成原理")
                    print(lst)
                    lst.extend(["计算机网络","操作系统"])
                    print(lst)
                    
                   结果：
                    ['数二', '英二', '政治', '数据结构']
                    ['数二', '英二', '政治', '数据结构', '计算机组成原理']
                    ['数二', '英二', '政治', '数据结构', '计算机组成原理', '计算机网络', '操作系统']
      		  
			  删:
			  	pop() -> 给出索引删除，同时返回被删除的元素
			  	remove() -> 给出 元素进行删除
			  
			  改:
			  	lst[x] = "xxx" -> 根据索引进行更改
			  	
			  查：
			  	lst[x] -> 根据索引进行查询
			  	
			   eg:
			   	lst = ['数二', '英二', '政治', '数据结构', '计算机组成原理', '计算机网络', '操作系统']
                res = lst.pop(2)
                print(res)
                print(lst)
                lst.remove("数二")
                print(lst)

                lst[1] = "数二"
                print(lst)

                print(lst[:])
                	
                结果:
                    政治
                    ['数二', '英二', '数据结构', '计算机组成原理', '计算机网络', '操作系统']
                    ['英二', '数据结构', '计算机组成原理', '计算机网络', '操作系统']
                    ['英二', '数二', '计算机组成原理', '计算机网络', '操作系统']
                    ['英二', '数二', '计算机组成原理', '计算机网络', '操作系统']
                    
                eg:  案列: 把所有姓杨的人改成姓杜
                    lst = ["杨延昭","杨宗保","易烊千玺","杨洋","吴京"]
                    for i in range(len(lst)):
                        if lst[i].startswith("杨"):
                            new_name = lst[i].replace("杨","杜")
                            lst[i] = new_name
                    print(lst)
                    
                   结果:
                   		['杜延昭', '杜宗保', '易烊千玺', '杜洋', '吴京']
                   		
               列表排序:
               		sort() -> 对于数字的列表按升序排列
               		sort(reverse = True) -> 对于数字的列表按升序降序
               		
               	  eg:
               	  		lst = [11,88,33,99,55,22]
                        lst.sort()
                        print(lst)
                        lst.sort(reverse=True)
                        print(lst)
                    结果:	   [11, 22, 33, 55, 88, 99]
							[99, 88, 55, 33, 22, 11]
							
              列表的嵌套：
              		lst=['数二', '英二', '数据结构',"["杨延昭","杨宗保","易烊千玺"]" , '计算机网络', '操作系统']
              		print(lst[3][2])
              	 结果： 易烊千玺
              	 
              列表的循环删除:
              		思路: 创建一个新列表存储要删除的元素
              		eg: 案列：删除姓杨的
              			lst = ["杨延昭","杨宗保","易烊千玺","杨洋","吴京"]
                        temp = []		#创建中间列表
                        for item in lst:
                            if item.startswith("杨"):
                                temp.append(item)
                        for item in temp:	#遍历中间列表，删除旧列表要删除的元素
                            lst.remove(item)
                        print(lst)
                     结果：['易烊千玺', '吴京']
      
      
      元组tuple:
      	特点:	不可变的列表 -> 可以有切片,
      	应用: 固定某些数据，不允许外界修改
      	格式: t = ('数二', '英二', '政治','408',['数据结构', '计算机', '计算机网络', '操作系统'])
      	eg:
      		t[1] = "数一"  -> 会报错，TypeError: 'tuple' object does not support item assignment 不支持重新定义
      		
      		t[4][2] = "计算机组成原理" 
      		print(t)
      	  结果: 	('数二', '英二', '政治', '408', ['数据结构', '计算机组成原理', '计算机网络', '操作系统'])
      	  
      	  注: 不可变是指元组中每个元素的内存地址不可变
      	  
      	当元组中只有一个元素时，末尾要加, -> 否则 就是字符串格式
      		eg : t1 = ("哈哈")
      			 print(type(t1))
      			 t2 = ("哈哈",)
      			 print(type(t2))
      		结果；
      				<class 'str'>
					<class 'tuple'>
      			
      		
     集合set:
     		特点；无序的
      		格式：s = {1,2,3,"呵呵哒"}
      		不可哈希: python中的set集合进行数据存储的时候,需要对数据进行哈希计算,根据 计算出来的哈希值进行存储数据
      				set集合要求存储的数据 是可以进行哈希计算的
      				可变的数据类型:set ->故set集合不能嵌套	 list	 dict
      		可哈希: 不可变的数据类型, int str tuple bool
      		创建空集合: s = set() 	注：set={} 数据类型为dict
      				  t = tuple()	创建空元组
      				  l = list()	创建空列表
      				  d = dict()	创建空字典
      				  s = str()		创建空字符串
      		集合的操作:
      			增:
      				add()
      			删:
      				pop() ->默认删除最后一个，犹豫集合无序,无法测试
      				remove（0 ->	按值删除
      			改:
      				先删除，在添加
      			查:
      				for循环进行查询
      				
      		补充: 
      			交集: &
      			并集: |
      			差集: -
      		  eg:
      		  	s1 = {'数二', '英二', '数据结构', '计算机组成原理', '计算机网络', '操作系统'}
                s2 = {'英二', '数据结构', '计算机组成原理', '计算机网络', '操作系统','408'}
                print(s1 & s2)	# print(s1.intersection(s2))	效果相同
                print(s1 | s2)	# print(s1.union(s2))
                print(s1 - s2)	# print(s1.difficience(s2))
                
               结果:
               		{'英二', '数据结构', '操作系统', '计算机网络', '计算机组成原理'}
                    {'英二', '数据结构', '操作系统', '数二', '计算机网络', '计算机组成原理', '408'}
                    {'数二'}
			
			重要作用:去除列表的重复,但是原来数据的顺序会发生改变
			
                lst = ['英二', '数据结构', '计算机', '计算机', '操作系统','408']
                print(list(set(lst)))

      		
    字典dict:
    		格式:dic = {key1:value1,key2=value2}
    			key的数据类型必须是可哈希的
    		字典的基操:
    		  增and改:
    		  	dic = dict()
    		  	dic["408"] = "计算机组成原理"
    		  	dic["408"] = "计算机网络"		#给同一个key赋不同值，会被替换
    		  	
    		  	dic.setdefault(key,value): ->设置默认值,如果以前已经有了默认值，setdefault()不起作用
    		  
    		  删:
    		  	dic.pop(key) -> 根据key进行删除
    		  	
			  查:
			  	dic[key] -> 如果key不存在，程序会报错
			  	dic.get(key) -> 如果key不存在，返回None()空类型
			  	
			  for循环:
			  	for i in dic:
			  		print(i,dic[i])		-> 循环遍历字典，拿到key和value
			  		
			  	print(list(dic.keys()))	-> 拿到字典所有的key,以列表的形式返回
			  	print(list(dic.values())) -> 拿到字典所有的value,以列表的形式返回
			  	print(list(dic.items())) -> 同时拿到字典所有的key和value
			  	
			  进阶: 利用解包(解构)
			  	for k,y in dic.items():
			  		print(k,y)
			  	
			  	eg；解包 变量和值数量上需要一一对应
			  		a,b=(1,2)
			  		c,d = [1,2]
			  		
			  字典的嵌套:
              	kaoyan = {
              		"数学" = "数二",
              		"英语" = "英二",
              		"政治" = {
              			"科目" : ["思修","毛概","马原"]
              		}
              		"408" = ["计算机网络","计算机组成原理","数据结构","操作系统"]
              	}
                  
               字典的循环删除: 思路:同列表删除,建立一个中间的列表存储要删除的元素
               		temp = []
               		for i in kaoyan :
               			if i.startswith("408"):
               				temp.append(i)
               		for t in temp:
               			kaoyan.pop(t)
               		print("kaoyan")
               		
                  结果:
                  		{'数学': '数二', '英语': '英二', '政治': {'科目': ['思修', '毛概', '马原']}}
	
    文件操作:
    	python中默认创建的文件的格式为UTF-8
    	格式:
    		f = open(文件路径,mode="",encoding="")
    	文件路径:
    		绝对路径: d:/test/python.py
    		相对路径: 相对于当前程序所在的文件夹
    			../  -> 返回上一层文件夹
    	mode: -> 模式
    			r : read 读取文本
    			  f.read() -> 全部读取
    			  f.readline() ->读取一行
    			  f.readlines() -> 读取每一行，放在返回的列表中
    			  for line in f:
    			  			循环读取f的每一行
    			w :  write 写
    			  f.write()
    				当前模式下如果文件不存在,会自行创建，同时，每次open都会清除文件中的内容
    				f.close() 	#每次操作完之后 要关闭 
    				进阶: with 每次操作完后不需要的f,close()关闭
    					with open(文件路径,mode="",encoding="") as f:
    						
    			a : append 追加写
    			
    			b: 对非文本文件操作
    				rb
    				
    	文件复制:
    			with open(旧路径,mode = "rb") as f1,\
    				open(新路径,mode = "wb") as f2:
    				for line in f1:
    					f2.write()
    			 
    			
    函数:
    	概念: 对某一个特定的功能或者代码块进行封装,需要使用时直接调用就行
    	格式: 
    	  定义:	def 函数名字():
    				被封装的功能或者代码块 -> 函数体
    	  调用:	函数名字()			
    	参数: 在函数调用时，给函数传递一些信息
    	  分类:  形参 -> 定义函数时的参数
    	  		实参 -> 调用函数时的参数
    	  		  1.位置参数
    	  		  2.关键字参数
    	  		  3.混合参数 -> 要求 ：位置参数放在关键字参数后面
    	  		 注意； 实参在执行的时候,必须保障形参有数据 
    	函数返回值: 函数执行完之后,会给调用方一个结果
    			return；
    					1.如果函数定义没有写return，函数返回None
    					2.函数如果只写了return,函数返回None,且return后续代码不会执行
    					4.return+值，表示函数有一个返回值,外界能接收到一个数据
    					4. return+值1，值2，值3...有多个返回值,外界收到的是元组,且该元组存放所有返回值
    	python内置函数: 可以直接拿来用的
    	函数的嵌套；
    		作用域: 变量的访问权限 -> 里面可以访问外面
    		
    		
    装饰器:
    
    
    
    
    迭代器and生成器:
    	迭代器: 
    			迭代是Python最强大的功能之一，是访问集合元素的一种方式。

                迭代器是一个可以记住遍历的位置的对象。

                迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

                迭代器有两个基本的方法：iter() 和 next()。

                字符串，列表或元组对象都可用于创建迭代器
              eg:
              		lst = [1,2,3,4,4]
                    it = iter(lst)
                    print(next(it))
                    print(next(it))
                    print(next(it))
                    print(next(it))
                    print(next(it))
              结果:
              		1
                    2
                    3
                    4
                    4
               
             	迭代器对象可以使用常规for语句进行遍历:
               eg:
               		lst = [1,2,3,4,4]
                    it = iter(lst)
                    for item in it:
                        print(item)
               结果: 同上
               
                也可以使用 next() 函数:
               eg:
                    import sys         # 引入 sys 模块

                    list=[1,2,3,4]
                    it = iter(list)    # 创建迭代器对象

                    while True:
                        try:           #异常处理
                            print (next(it))
                        except StopIteration:  
                        # StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置							在完成指定循环次数后触发 StopIteration 异常来结束迭代
                            sys.exit()
               
               
        生成器: 在 Python 中，使用了 yield 的函数被称为生成器（generator）。

            跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

            在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行
            
            next() 方法时从当前位置继续运行。

            调用一个生成器函数，返回的是一个迭代器对象。
          eg: 使用 yield 实现斐波那契数列

                import sys

                def fibonacci(n): # 生成器函数 - 斐波那契
                    a, b, counter = 0, 1, 0
                    while True:
                        if (counter > n): 
                            return
                        yield a
                        a, b = b, a + b
                        counter += 1
                f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

                while True:
                    try:
                        print (next(f), end=" ")
                    except StopIteration:
                        sys.exit()
               		
    	推导式: 简化代码
    			列表推导式: [数据 for循环 if]
    			集合推导式: {数据 for循环 if}
    			字典推导式: {k:v for循环 if}
    	生成器表达式:
    	
    	
    	
    匿名函数:
    		lambda表达式:
    			格式:
    				变量 = lambda 参数1,参数2... : 返回值