python三目运算符_Python十日谈

python基础第一天2.16日

重点内容：
        1.了解计算机组成原理（**）
	2.掌握注释内容（***）
		单行注释 #
		多行注释 ”“”“”“
	3.变量以及类型（*****）
		int 整形
		float 浮点型，小数
		bool 布尔类型，ture，false
		string 字符串类型
		命名规则：大驼峰，小驼峰，下划线命名
		命名变量：由数字，字母，下划线构成，数字不能开头，不能有特殊符号，不可为关键字
		变量区分大小写
		关键字 # import keyword 
			  # keyword.kwlist

预习内容：
	输入输出 *****
	运算符 ****
	数据转换 ***
	判断语句 *****（语法，if嵌套）


Python基础班二天2.17日
重点内容：
	快捷键：pycharme转换到代码定义
		win：ctrl + b
		Mac：command + b
	在一行内输出需要进行换行显示：n，换行符，相当于回车键

	name = '1'
	age = '2'
	输出：print(name, age, sep:':', end='')  
	'1':'2'
		参数:sep,表示多个数据的分割符
		    end,表示在输出数据末尾追加制定数据，print输出内容会自动换行，end='n'
	格式化输出：将字符串内容动态内容按照指定格式进行输出，解决字符串有动态内容
		a = ’崛起‘
		print("武汉%s" % a)
		常用格式化占位符： %d，整型；
							扩展：%03d；表示数据不够3位前面补0
						%s，字符串；
						%f，浮点型;保留6位小数
							扩展：%.2f；表示保留两位小数
								 %.1f；表示会四舍五入
						%%，代表一个百分号；

	输入：接收用户在控制台输入的数据，input()
		 使用变量保存input接收的函数，接收的函数类型为string

	运算符:1.算数运算符；/,除（返回结果为float）；
					  //,取整除（求商）；%,取余；**,指数
		  2.赋值运算符; = ，支持连续赋值，a = b = 5
		  3.复合赋值运算符；python不支持，++，-- 
		  			  例如：a /= b -----> a = a / b 
		  4.比较运算符，结果为bool类型；
		  5.逻辑运算符，and，or，not

	数据类型转换：只有数据类型统一才能进行相关计算
		int(),folat(),string(),eval()获取字符串内原始内容

	
	if判断语句（****）
		if True（条件成立）：
			执行代码块
		if False（条件不成立）：
			不执行代码块
		
		a = 'dhkadsf' ---->Ture
		if a: --->如果a非0，条件恒等于真，后面代码块执行
			print('yeah!')


		if 判断条件：  注意：if和else语句互斥，只能满足一个条件
			执行代码块
		else：
			执行条件不满足的代码块

		if 判断条件1：
			执行代码
		elif 判断条件2：
			执行代码块
		elif 判断条件3：
			执行代码块
		else（可选）：
			以上条件不满足执行

		三目运算：print('a') if 2>1 else print('b')


		if语句嵌套
预习内容：
	循环语句（*****）：while，for
	字符串（*****）：记忆的东西非常多，一定要进行预习
		  下标和切片（可能听起来比较懵逼）
		  字符串的操作（课上共24个方法，需要记忆，但课上肯定记不完全，
		  			需要课下进行联系巩固）


Python基础班三天2.18日
重点内容：
	导入random模块，随机生成整数，random.randint()
	例如：random.randint(1,3)  ---> [1，3] 1,2,3

	循环语句（*****）：能够重复执行程序中的代码片段
	1）while 循环语句
	语法格式:while 判断条件： 
				执行循环内代码块
	while循环语句会一直进行判断条件是否成立
	为保证不是死循环，需要给循环制定限制条件

	while循环语句嵌套
	语法格式:while 判断条件n：---->外部一层代表缩进代码块循环
				执行相关代码块
		 		while 判断条件m：----->内部表示代码块1循环
		 			执行相关代码块1
	执行顺序：先判断外层循环，如果条件成立，执行内部代码
			如果内部有循环，执行内部循环，直至内部循环结束
			再次进行外部循环，如果条件成立，执行内部代码
			总共执行n*m次
	难点：如何判断终止条件
	2)for 循环语句  
	语法格式:for 临时变量 in 字符串（可迭代类型）：
				输出临时数据
	for 循环对可迭代对象类型进行遍历，可结合 range 和 else 进行使用
	range：数据范围；返回的结果是一个列表
	range（1，2，1）;[1,） ，最后一个参数为步长，步长可为负数
	range(1,9,2)  ----> [1，3，5，7]
	range(3,1,-1) ----> [3，2]
	3）只能循环内使用的关键字break和continue
	break：终止所在循环
	continue:跳出当前循环，继续下次循环，循环并没有结束
	4）循环配合 else 使用
	语法格式：
		（1）while 判断条件：
		   		循环的代码块
		    else:
				当 while 内没有执行 break 执行的代码块
		（2）for 临时变量 in 可迭代对象：
				循环的代码块
			else：
				当 for 内没有执行 break 执行的代码块

	字符串（*****）：字符集合，使用引号包含
	1）fstring：对字符串中的动态数据进行绑定，只支持python3.6以上解释器版本
	语法格式: f/F"{数据/变量}"  ===>必须用大括号没有为什么，语法格式，规定
	字符串中的动态内容进行数据绑定的两种方式：
		（1）格式化占位符（通用）print('%s' % name)
		（2）fstring
	2）下标，数字用于根据下标获取指定数据
	正数下标从0开始，表示第一个位置
	负数下标从-1开始，表示最后一个位置
	下标不能越界
			zifuchuan = 'abcde'
	 正数下标：01234
	 负数下标：-5-4-3-2-1	 

预习内容：
	字符串切片(*****)
	字符串的相关操作，共24个方法，一定要提前预习，了解各个方法的作用
	列表（*****）
	列表相关方法，增删改查

Python基础第四天2.20日
重点内容：
	字符串切片（*****）
	1）切片: 根据下标范围获取部分数据，切片结合字符串，列表，元组使用
	   下标: 获取一个数据
	切片语法格式:变量[开始下标: 结束下标: 步长(默认为1)]
	切片范围：前闭后开，参照 range
	开始下标不指定为0，结束下标不指定表示获取到最后一个位置
	开始下标和结束下标都不指定，即切片获取整个字符串
	步长为正数，从左往右取值；步长为负数，从右往左取值
	m_str = 'abcde'
	a= m_str[:]

	2）字符串相关方法（*****）str
	(1)find:根据字符串获取对应下标，找不到返回-1，即无数据
	   可以指定查找范围
	   rfind,从右往左进行查找
	ex：a = m_str.find('a', 0, 3) ===> [0,3) ===> 0
	   
	(2)index:功能和find一样，如果找不到数据报错
	(3)count:统计指定字符串出现的次数
	   可以指定统计范围
	ex：a = m_str.count('a', 0, 3)
	(4)replace:替换
	参数一要替换的字符；参数二替换成的字符；参数三替换的次数，不指定全部替换
	ex: a = m_str.replace('a', 'b', 1)
	(5)split:指定数据分割，返回一个列表
	参数一指定分割的字符；参数二最大分割次数
	如果不指定参数，按照空白字符(空格，n, t)分割
	b = 'a,b,c'b
	ex: a = b.split(',') ===> type(a) ===>list
	(6)startswith:判断是否以指定字符串开头
	(7)endswith:判断是否以指定字符串结尾
	(8)strip:去除两边的空白字符 ===> ' abv '
	(9)lstrip,rstrip:去除左右两边空白符 l = left(左); r = right(右)
	(10)partition:根据指定数据，把数据分割成三部分，返回元组
	    rpartition:从右往左进行查找
	(11)isdigit:判断字符串内是否都是整型数字
	(12***)join:根据指定数据对容器中内个数据进行拼接，返回一个新字符串
	ex:my_list = ['1', '2']
	my_str = '_'.join(my_list)

	3）列表（*****） list
	存储任意类型数据的容器，list 
	格式：[数据1， 数据2, ...]
	获取列表中某一数据，通过下标
	动态获取列表中的长度，len() 函数，返回值为int类型
	列表的遍历
	a = [1, 2, 4，5]
	for i in a:
		print(i)

	index = 0 
	result = len(a)
	while index < result:
		b = a[index]
		index += 1

	定义空列表： a = list()  or  a = []
	列表操作方法：
		1）增加
		a.append()           追加数据
		a.insert(0, 'x')     在指定位置插入数据
		a.entend(b) 扩展数据，把列表中数据添加到a中
		2) 修改
		利用下标进行修改
		a[0] = 'b'
		利用切片进行修改
		a[: 2] = ['a', 'c']
		3) 删除
		del a[1]    删除指定位置数据
		a.pop()     删除最后一位数据
		a.pop(0)    删除指定位置元素
		a.remove(2) 删除列表内指定元素，且改元素必须存在
		4) 查看
		a[1]  通过下标
		a[:2] 通过切片查看
		通过遍历查看
		in     判断指定数据是否在列表内
		not in 判断制定数据是否不存在
		5）其他常用方法
		a.index()  根据指定数据获取数据的下标，如果数据不存在，崩溃
		a.count()  根据指定元素统计改元素出现的次数
		a.sort()   对列表进行排序，默认升序  参数reverse=True，反转
		每一个字符都对应一个数，先把这个字符转换成数，进行排序，再把这个数转换成源字符
		a.reverse()对列表进行降序，先排序在反转
		6）列表嵌套
		[[]]

预习内容：
	元组：查
	字典：key:value，CURD，增删改查


Python基础第五天2.21日
重点内容：
	1）元组（***）tuple
	一种容器类型，可以存储多个数据，元组中的数据不能修改，可存放任意类型数据
	格式： 变量 = （数据1,数据2, ...） 
	如果元组中只有一个元素 ,(逗号)不能省略
	元组使用场景：
		（1） 字符串格式化输出 
		（2） 函数返回值
	元组操作方法：
		1）查找，利用下标进行查找；利用切片查找数据
		2）index()，指定数据查找改数据的下标
		3）count(), 指定数据在元组中出现的次数
	元组的遍历：(建议使用 for 循环遍历)
	a = ('a', 'b', 'c')
	for i in a:
		print(i)


	index = 0
	while index < len(a):
		value = a[index]
		print(value, index)
		index += 1
	2）字典（*****） dict
	一种容器类型，可以存储多个键值对数据
	获取数据更方便，可读性强,字典无序
	dict 在3.6之前无序，3.6之后有序，即输出字典的键值对和输入时数据一致
	格式：{'key': 'value', ...}
	字典使用场景：对应描述信息的存储
	定义字典：a = dict()  or  a = {}
	字典操作方法：
		1）取值
		使用中括号取值，value = a['key'],如果key不存在，报错
		使用get方法取值，第一个参数key键，第二个参数设置默认值
		value = a.get('key')，key不存在，返回None(空值)
		2）增加
		a = {'b':'abc'}
		a['b'] ==> 'abcde'
		a['b'] = 'abcde'  b这个key键在字典中没有，即为增加
		增加多个，进行字典遍历
		a ={}
		b = {'a':'1', 'b':'2'}
		for key, value in b.items(): 
    		a[key] = value
		print(a)
		使用update方法
		dict1.update(dict2)
		3）修改
		a['b'] = 'abcde'  b这个key键在字典中存在，即为修改
		4) 删除
		del dict1['key']  del关键字删除
		dict1.pop('key')  使用pop根据key进行删除
		dict1.clear()     清除字典内所有数据，该方法也适用于列表
		dict1 = {} or dict1 = dict()
		5）字典常用方法
		len()    获取字典中键值对的长度
		keys()   返回dict_keys类型，获取字典中的键
		values() 获取字典中所有的值
		items()  获取字典中所有的项，每项数据都是元组
		6）遍历字典
		for key in dict1.key():  =====  for key in dict1
		for values in dect1.values():
		for key, values in dict1.items():
	3)python高级方法的使用（****）
	enumerate() 使用for循环的时候，即要获取下标又要获取数据
	字符串，列表，元组，字典都可使用该方法
	但是对于字典下标无用，可判断第几项
	4）在python3.6之前使用有序字典，使用OrdereDict
	OrdereDict是一个类,继承dict
	即 orderedict = OrdereDict()
	5)合并（+） 复制（*） 存在（in) 不存在（not in)
	6)python 内置函数
	len()			获取容器类型中元素个数
	max()			获取容器中最大值
	min()			获取容器中最小值
	del  or del()   删除变量，以后改变量不再使用
	7)函数（*****）
	实现一段功能代码，目的实现代码复用，减少代码冗余
	使用方法：定义函数，调用函数 
	语法格式：def 函数名():
				功能代码
	函数名由数字，字母下划线组成，不能数字开头
	def show_info():
		for _ in range(3):  # 每次得到的数据不适用用下划线替换
			print()
	show_info()

	def info():
		pass

预习内容：（****）
	函数的参数 
	函数的返回值
	函数的嵌套
	变量 ：局部变量，全局变量
	引用，指向一块内存空间
	可变类型和不可变类型
	递归

Python基础第六天2.22日
重点内容：
	1）函数 （*****）
	函数文档说明，在函数名下的多行注释，说明函数实现的功能
	查看函数的说明文档：help(函数名)
	2）函数参数
	函数名(参数一, 参数二, ...)
	实参  ---> 实际参数
	形参  ---> 形式参数
	def show(形参1， 形参2):
		pass
	show(实参1， 实参2)
	3）函数返回值
	def show(a):
		pass
		return 返回值
	result = show(a)
	4) 函数的嵌套
	def fun1():
		def inner():
	5)局部变量：函数内定义的变量，只作用于当前函数，不能在其他函数使用
	  全局变量：函数外定义的变量，不同函数都可使用，可以在不同函数共享数据
	  修改全局变量：
	      1）global 关键字申明
	      2）函数提供返回值
	6) return只能返回一次，当执行return表示函数执行结束，后面代码不执行
	   返回多个值使用列表，元组，字典
	7）缺省参数，定义函数是给函数的形参设置默认值 
		注意：缺省参数后不能再定义非缺省参数，可以再定义缺省参数
	8) 传参方式
		1）位置传参
		2）关键字传参
		3）前面是位置后面是关键字，关键字后面不能使用位置


Python基础第七天2.24日
重点内容：
	1）不定长参数
	不定长位置参数：*args ,专门接收位置参数，args是元组
	不定长关键字参数：**kwargs， 接收函数调用时的关键字参数，是字典，放最后
	因为定义函数的时候使用不定长参数，在调用的时候所有参数需要位置参数的方式进行传参
	缺省参数通过位置进行传参，缺省参数在不定长参数(*args)后面
	def show(name，*args, d=10, **kwargs):
		pass

	show(10, 20, 30，a=10, b=20, c=10)

    name = 10
    c = 10
	args = (20,30)
	kwargs = {'a':10, 'b':20：'c':10}
	2）拆包：使用不同变量对容器中每个数据进行保存,str，list，tuple，dict,range
	3）交换两个变量的值，a, b = b, a
	4）引用：使用变量保存数据在内存中的地址，变量存储的是内存地址
	查看变量存储的内存地址：id()
	5)可变类型：列表，字典，集合，内存地址改变
	  不可变类型：数字，字符串，元组，内存地址不变
	  不管可变还是不可变，只要给变量重新赋值，内存地址改变
	6）函数注意点
	return 只返回一次，return执行表示函数执行结束，只能在函数中或者方法内使用
	函数名相同，后面的函数会覆盖前面的
	作用域

Python基础第八天2.25日
重点内容：
	1）学生管理系统
	global 本质是声明要修改全局变量的内存地址
	对可变类型来说，修改全局变量数据，如果在原有内存空间基础上修改，可不加global
	只要给全局变量重新赋值，不管可变不可变，都要加global声明全局变量
	2）递归函数：在一个函数里面再次调用函数本身
	递归函数必须要有结束条件，否则会蹦会，超出最大递归次数（默认1000）
	3）匿名函数，使用lambda 关键字定义的函数为匿名函数
	简化普通函数的代码实现，也属于函数，调用加上括号
	匿名函数只能一行代码，返回值不需要加 return，不能实现复杂的功能
	匿名函数也是能够作为参数给其他函数使用
	func1 = lambda x, y: x + y
	func2 = lambda:print('这是无参的匿名函数')
	func2()
	4）列表推导式(*****)
	使用列表结合 for 循环快速创建一个新的列表，返回一个列表
	格式：[把每个value添加列表里 for value in 容器类型数据]
	my_str = 'abcde'
	new_list = [value * 2 for value in my_str]
	new_str ====> ['aa', 'bb', 'cc', 'dd', 'ee']

	new_list2 = [random.randint(1, 10) for _ in range(5)]

预习内容：
	集合 set (***)
	高级函数 （*****）
	文件操作：（****）
		新建文件，追加文件内容，查看文件目录，查看目录内文件，文件的相关操作


Python基础第九天2.26日
重点内容：
	1）集合 set 
	一种容器类型，可以存储多个数据 {1, 2, 3, ...}
	利用集合对容器类型中数据进行去重
	特点：无序，数据唯一性，可变类型
	集合操作方法：
		my_set.add()		增加
		my_set.remove()	 	删除
		my_set.clear()	 	清除集合中数据
	不能通过下标获取和修改集合中数据
	定义空集合，使用 set()
	集合里面只能存储不可变类型数据（数字，字符串，元组，range）
	获取集合中的数据：
		(1) for 遍历
		(2) 拆包
	列表，元组，集合三者之间可以相互类型转换  
	2）高阶函数
	函数的参数或者返回值都是一个函数，这样的函数为高阶函数
	函数的返回值是一个函数--闭包
	from functools import reduce 
	reduce() 根据指定函数的功能对容器类型中的每个一个数据进行相关计算
	用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作
	得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
	filter() 根据指定函数的功能对容器类型中的每一个数据进行过滤
	list1 = [1, 2, 3, 4, 5]
	result = reduce(lambda x, y : x+y, list1)
	my_list = ['ab', 'cd', 'acd']
	new_filter = filter(lambda value: value.endswith(), my_list)
	匿名函数经常和高阶函数一同使用
	3) 文件操作
	可以把程序中的数据保存到文件，让文件对数据进行永久保存
	1字节 = 8bit, 1bit存储1/0中的一个数
	win的python解释器编码格式为gbk，linux和mac默认utf-8
	文件操作模式：
		(1)r(read)模式：  以字符串的方式读取数据
		文件必须存在，否则程序崩溃
		如果没有指定文件路径，默认打开当前目前的文件
		(2)w(write)模式：  以字符串的方式写入到文件
		打开文件时，如果文件存在会清空文件中的数据，如果没有文件则创建一个文件
		(3)a(add)模式：  以字符串方式向文件追加数据
		如果文件存在，之前数据保留，进行数据追加，如果文件不存在则创建一个文件
		(4)rb模式： 以二进制的方式读取文件中的数据
		(5)wb模式： 以二进制的方式写入数据到文件
		(6)ab模式： 以二进制的方式追加数据到文件
	文件相关方法：
		(1)file = open('1.txt', 'w', encoding='utf-8')  
		打开文件，参数一文件名字，参数二操作模式，参数三编码格式，返回一个文件对象
		(2)file.read()
		读取文件中所有数据
		(3)file.close()
		关闭文件
		(4)file.write('数据')
		写入数据


Python基础第十天2.28日
重点内容：
	1）文件操作
	如果以二进制方式进行文件操作，不用进行编码utf-8
	在utf-8的编码格式下，一个汉字3个字节，一个字母或者数字或者符号都是一个字节
	read(数据长度)		读取文件中所有数据，如果是r模式则读取字符串长度数据
						如果是rb模式则读取字节长度数据
	readline()			每次读取一行数据，默认第一行，遇到换行符，表示一行读取完毕
	readlines()			读取文件中所有的行数据，每行数据存放列表，返回 list
	读取的数据转为字符串，result.decode('utf-8')
	修改文件名，使用字符串分割拼接方法
	操作文件或者文件夹的模块：os 模块  文件操作高级模块：shutil 模块
	os.rename()			文件重命名
	os.remove()			删除文件
	os.mkdir()			创建文件夹
	os.rmdir()			删除空的目录(文件夹)
	shutil.rmtree() 	参数内填路径目录，删除目录以及里面所有文件
	a = os.listdir()
	type(a) ==> list
	for list		
						不指定参数默认查看当前工程内所有文件名，参数内可制定目录，返回列表
	os.getcwd()			查看当前操作目录路径   
	os.chdir()			切换目录  

	os.path.exists()	判断文件或目录是否存在
	os.path.isfile()	判断是否是一个文件
	os.path.isdir()		判断是否是一个目录
	os.path.splitext()	获取文件的文件名和后缀
	os.path.basename()	获取路径中的文件名
	os.path.dirname()	根据指定路径获取文件夹部分的路径
	os.path.abspath()	根据文件名获取完整路径