数据类型:

list(列表)

可以理解为python中的数组：
       1.数组元素类型可以不同
       2.数组元素个数没有固定
       3.数组的内容可以更改
           但是，如果数组的元素是字符串、元组，想要更改字符串或者元组里面的内容是不可以的，因为这两个数据是不可以更改的

可以理解为：QList <void *> arr;

例：

l = [1,2,3,4,5]
l1 = [1,3.14,-5,"tom",[1,2,3],('d','b',2),{'key':5,'con':"bin"},{1,3,4}]
'''
print(type(l))
print(type(l1))for x in l1:print(x,type(x))print(l1[3])
print(l1[4][1])
'''
print(l1)
l1[3] = "Jerry"
print(l1)
#上面可以更改，是因为list可以更改
#下面不可以更改，是因为str不可以改
l1[3][0] = 'H'
print(l1)

如何定义:

列表名 = [元素1,...,元素n]

获取列表中的某一个元素：列表名[下标]
下标从0开始

列表的截取：
列表名[start:stop:step]
start、stop、step的属性特点同str截取

例：

myl = [1,2,3,4,5,6,7,8]
for i in range(len(myl)):print(myl[i])print(myl[-1::-1])
print(myl[::2])

列表操作：
sort():排序
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

/*
           *reverse:默认为False：即为升序
           *reverse:设为True：即为降序
           */

index(元素内容):查找位置
返回元素在列表中的下标(从左往右第一个)，如果元素不在，则抛异常

append(元素内容):在末尾追加元素内容
如果追加的数据是，list，tuple，dict，set都会当作一个元素追加

clear():删除list中的所有元素
       remove(object_value):删除list中值为object_value的从左往右第一个元素，
                           如果该元素的值不存在与list中，则，抛异常
       count(obj_value):统计obj_value在list中出现的次数
       pop():将list最后一个元素删除
       insert(index,obj_value):在list的index下标位置，插入值为obj_value的元素

方法函数：
max(object)：求object中的最大值
min(object)：求object中的最小值

例：

li = [23,-3,45,21,89, -2, -2, 0, 78]
print(li)
#list的排序，默认升序
li.sort()
print(li)
#让reverse参数设置为True，为降序
li.sort(reverse=True)
print(li)print(li.index(-2))
#print(li.index(100))
print(li.append(21))
print(li)
l2 = ['Tom',"Nick","Lisa"]
li.append(l2)
print(li)
li.pop()
print(li)
print(max(li))

li = [1,2,2,3,4,5,2,6]
#将list最后一个元素删除
li.pop()
print(li)
#求list(要求list中必须都是数字)最大值
print(max(li))
#求list(要求list中必须都是数字)最小值
print(min(li))
#删除从左往右数第一个为该值的元素，如果元素不存在则抛异常，这个没有默认参数，所以必须给一个值
li.remove(2)
print(li)
#求某个值在list中出现的次数
c = li.count(2)
print(c)
#在list的指定位置插入数据
li.insert(3,"Tom")
print(li)
#删除list中的所有元素
li.clear()
print(li)

->截取：
   字符串、元组、列表
       变量名[start:stop:step]
           从下标为start的位置开始，到stop位置结束，每隔step个元素获取一次

li = [1, 2, 3, 4, 5, 6, 7, 8]
正向下标 0 1 2 3 4 5 6 7
反向下标 -8 -7 -6 -5 -4 -3 -2 -1

左闭右开
       li[1:5:1]
           li[1,5):范围
           结果： 2，3，4，5

    for i in range(1,5,1): print(li[i],end=" ")

->拼接:

li = ['a','l','l']str1 = "".join(li)
print(str1,type(str1))

元组

元组的定义:
python中用"()"括起来的数据赋值给变量，该变量类型为元组。

元组数据类型的特点：
           1.不能更改
               ->里面的内容
               ->即不能插入和删除
           2.只能查找和统计
           3.元组的元素类型可以不同
           4.可以更改里面可改元组的内容

       元组的操作：
           index(元素内容):查找位置
           返回元素在元组中的下标(从左往右第一个)，如果元素不在，则抛异常
           count(obj_value):统计obj_value在tuple中出现的次数       元组也可以截取：
   例：

        t = (1,2,3,4,"tom",[1,2,4],(1,2,3),{'姓名':"李逵","别称":"铁牛","口头禅":"你个鸟人"},\{'Tom',"Jack"}, "tom")print(t.count("tom"))print(t.index({'Tom',"Jack"}))t[5][0] = 89t[7]['口头禅'] = "哥哥"print(t)

字典

python中的键值对
       变量名{
           key1:value1,
           ...
           keyn:valuen
       }

key一定是不能改变的

例：

mydic = {'UID':13312653876,'昵称':"RMB-YYDS",'等级':5,'角色':"武则天"
}
#打印字典
print(mydic)
#打印字典中指定的key的值
print(mydic['昵称'])
#更改字典中的key的值
mydic['角色'] = "嬴政"
print(mydic)
#设置字典中指定的key的值，如果该key不存在，则添加
mydic['ADC'] = "中路"
print(mydic)
#获取字典中的每一对键值，将所有键值对，存入一个list，而键值对则以元组形式输出
print(mydic.items())
#获取字典中的所有key，将所有key存入一个list
print(mydic.keys())#删除字典中指定的键值对
mydic.pop('等级')
print(mydic)
#清空字典
mydic.clear()
print(mydic)

集合

定义
       集合的定义有两种方式:
           set(list):list中添加集合的元素
           {枚举集合中的元素}

集合的输出：
集合的输出没有顺序性，它将会随机输出所有元素

集合运算：
       print(a-b)   #集合a中包含而集合b中不包含的元素       （a对于b的补集）
       print(a|b)   #集合a或集合b中包含的所有元素           (并集)
       print(a&b)   #集合a和b中都包含的元素               (交集)
       print(a^b)   #不同时包含于a和b的元素               (并集-交集)

内置方法：
       add()：
           add方法可以给集合添加元素，但是只能添加字符串和整数，其他的不行（list, tuple, dict, set）
       pop():
           pop()随机删除集合中的某个元素

remove():
           remove():从集合中删除指定元素
       issubset():
       issubset(集合1)：该集合是不是集合1的子集，返回值为bool类型
       clear():
           clear():清空集合

#使用set()构造函数，构造一个集合，只有一个参数，参数是一个list
myset = set([3,5,7,8,1,9,6])
print(myset,type(myset))
'''
mynset = {3,9,7,40,2}
print(mynset, type(myset))print("myset中包含，而mynset中不包含的元素：",myset - mynset)
print("myset中包含，或者mynset中包含的元素：",myset | mynset)
print("myset中包含，且mynset中包含的元素：",myset & mynset)
print("myset中包含，而mynset中不包含 或 mynset中包含，而myset不包含的元素：", mynset ^ myset)
'''
'''add方法可以给集合添加元素，但是只能添加字符串和整数，其他的不行（list, tuple, dict, set）
'''
myset.add('y')
myset.add("hello")
#myset.add({'y','c','t'})
#myset.add({'name':"Jack", "Chinese name":"李狗蛋"})
print(myset)'''pop()随机删除集合中的某个元素
''''''
myset.pop()
print(myset)myset.pop()
print(myset)myset.pop()
print(myset)
'''#remove():从集合中删除指定元素
#myset.remove('hello')
print(myset)'''issubset(集合1)：该集合是不是集合1的子集，返回值为bool类型
'''myt = set(['hello','y',8])
ret = myset.issubset(['hello','y',8])
print(ret)ret = myt.issubset(myset)
print(ret)#clear():清空集合
print(myt)
myt.clear()
print(myt)

python中的数据类型总结：
不可更改的数据类型：
数字、字符串、元组

可更改的：
list、dict、set

python中的三种基本结构

->顺序结构
一句一句执行的结构
包含一定的先后顺序

难度在于如何设计程序流程

->分支结构
难度在于设计判断条件

->单分支：
if xxxx:
语句块

->双分支:
           if xxx：
               语句块1
           else：
               语句块2
       ->多分支：
           if 条件1：
               语句块1
           elif 条件2：
               语句块2
           ...
           else：
               语句块n+1
   ->循环结构
       ->for循环
           for 循环变量 in 枚举的循环变量范围:
               循环体

->while循环
while 循环条件：
循环体

循环条件中使用的条件运算符：
       操作符       描述
       <           小于
       <=           小于或等于
       >           大于
       >=           大于或等于
       ==           等于，比较两个值是否相等
       !=           不等于

逻辑与： and
逻辑或： or

i = 8
c = 9if i < 10 or c > 10:print(i+c)

def person_do_work():print("吃奶，睡觉")print("吃，学习基本行动技能，睡觉，说话")print("学奴时代开启")print("请输入是否考上大学:(1:985/211 2:普通本科 3:其他)",end=":")ret = input()if(ret == '1'):print("开启开挂人生")elif(ret == '2'):print("开启奋度人生")else:print("开始打工，吃土")def study_work():i = 0flag = 0while i < 140:myclass = input()if(myclass == "1"):con = input()if(con == "留学"):flag = 1breakelif(con == "考试作弊"):flag = 0breakprint("开启学习")i += 35if i < 140 and flag == 0:print("取消毕业资格，只能肄业")elif i < 140 and flag == 1:print("保送国外留学")elif i < 140 and flag == 2:print("国内保研")else:print("辍学")#person_do_work()
study_work()

注意：python中没有do while循环
python中没有swicth case多分支

文件操作

python File(文件)方法

open()方法：
python open()方法用于打开一个文件，并返回对象，在对文件进行处理过程都需要使用这个函数，如果该文件无法被打开，会抛出OSError。
注意：使用open()方法一定要保证关闭文件对象，即调用close()方法。
open()函数常用形式是接收两个参数:文件名(file)和模式(mode)

open(file, mode='r')

#python使用open来打开文件
f = open("myset.py","r",encoding="utf-8")
#read()可以读出文件的所有内容
con = f.read()
print(con)
#文件操作完成时，需要close关闭操作对象
f.close()

完整的语法格式：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
   参数说明：
       file：必须，文件路径(相对或者绝对路径)
       mode：可选，文件打开模式
       buffering：设置缓冲
       encoding：一般使用utf8
       errors：报错级别
       newline：区分换行符
       closefd：传入的file参数类型
       opener：打开着

mode参数有：
       模式       描述
       t 文本模式(默认)
       x 写模式，新建一个文件，如果该文件已存在则会报错
       b        二进制模式
       +       打开一个文件进行更新(可读可写)
       U       通用换行模式(python 3不支持)
       r       以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
       rb       以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
       r+       打开一个文件用于读写。文件指针将会放在文件的开头
       rb+       以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
       w       打开一个文件只用于写入，如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
       wb       以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
       w+       打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
       wb+       以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
       a        打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
       ab       以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
       a+       打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写
       ab+       以二进制格式打开一个文件用于追加。如果该文件已经存在，文件指针将会放在文件的末尾。如果该文件不存在，创建新文件用于读写

默认为文本模式，如果要以二进制模式打开，加上 b

with open("myfile.txt", "a+", encoding="utf-8") as f:f.write("Hello!\n")f.write("My Name is Jack! \nWhat 's your name?\n")f.writelines(['哥哥，下山走一遭\n','你这黑厮\n','这趟有多少富贵\n'])

with open("myfile.txt","r",encoding="utf-8") as f:#con = f.readlines()con = f.readline()print(con)

python下的文件夹操作

1.创建文件夹
#这是os包提供的方法，用来创建文件夹，使用时，需要导包:import os
os.mkdir(dirname)

2.删除文件夹
os.rmdir(dirname):删除空文件夹

3.查看文件夹的内容：
os.listdir(dirname):得到文件夹中内容的列表

4.在脚本中执行一个命令
os.system(cmd)：执行cmd命令

5.删除文件：
os.remove(filename):删除指定的文件

import osos.mkdir("mydirectory")with open("mydirectory/mytest.py", "a+", encoding="utf-8") as f:f.write("print(\"铁牛，你这黑厮！\")\n")os.system("python mydirectory/mytest.py")

import osl = os.listdir("mydirectory")
print(l)
path = "mydirectory/"
for x in l:fn = path+xos.remove(fn)os.rmdir("mydirectory")

6.递归获取文件夹内容：
os.walk(dirname)：递归获取文件夹下所有内容
是有多个元组构成的一个迭代器:（类似于数组的东西）
元组的构成：
(当前文件夹父目录的路径，当前文件夹下所有文件夹的列表，当前文件夹下所有普通文件的列表)

import osl = os.walk("D:\\嵌入式学习笔记\\python")
print(l)fl = []for x in l:#print(x)if(len(x[2])):for f in x[2]:pf = x[0] + "\\" + f#print(pf)fl.append(pf)print(len(fl))

练习：统计文件夹下.c/.h/.py的个数，并计算所有以上类型文件的总行数

import osl = os.walk("D:\\嵌入式学习笔记\\python")
print(l)fl = []
file_C = 0
file_h = 0
file_py = 0
count = 0for x in l:#print(x)   if(len(x[2])):for f in x[2]:pf = x[0] + "\\" + fif os.path.splitext(pf)[1] == ".c":#将对应的文件与文件名分割file_C += 1 for index,line in enumerate(open(pf,'r',encoding="utf-8")):count += 1if os.path.splitext(pf)[1] == ".h":file_h += 1 for index,line in enumerate(open(pf,'r',encoding="utf-8")):count += 1if os.path.splitext(pf)[1] == ".py":file_py += 1 for index,line in enumerate(open(pf,'r',encoding="utf-8")):count += 1#print(pf)fl.append(pf)print("总文件数：",len(fl))
print(".c文件数:",file_C)
print(".h文件数:",file_h)
print(".py文件数:",file_py)
print("以上文件类型总行数:",count)

函数

使用函数的目的：
       1.代码复用
       2.让代码模块化
       3.便于阅读和调试

定义一个函数
   你可以定义一个由自己想要功能的函数，一下是简单的规则：
       >函数代码块以def关键词开头，后接函数标识符名称和圆括号()
       >任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义函数
       >函数的第一行语句可以选择性地使用文档字符串——用于存放函数说明
       >函数内容以冒号起始，并且缩进
       >return [表达式]结束函数，选择性地返回一个值给调用方。不带表达式地return相当于返回None

def 函数名(形参列表):
函数体
return [表达式]

语法：
       python定义函数使用def关键字，一般格式如下：
           def 函数名(参数列表):
               函数体
       默认情况下，参数值和参数名称是按函数声明中定义地顺序匹配起来的。

函数调用
接收返回值的变量 = 函数名(参数列表)

参数传递：
   python中，类型属于对象，变量是没有类型的
   a = [1,2,3]
   a = "hello"

以上代码中，[1,2,3]是list类型，"hello"是String类型，而变量a是没有类型，她仅仅是一个对象的引用(一个指针)，可以是指向List类型对象，也可以是指向String类型对象

可更改(mutable)与不可更改(immutable)对象
       在python中，strings、tuple和numbers是不可更改的对象，而list，dict等是可以修改的对象
           不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
           可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python函数的参数传递：
不可变类型：类似 c++ 的值传递，如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，如列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

例子：

            def changeint(a):a = 10def changelist(mylist):mylist.append(["hello",1,34])print("changelist:",mylist)returnb = 2print("before changeint:",b)changeint(b)print("after changeint:",b)myl = [10,20,30]print("before changelist:",myl)changelist(myl)print("after changelist:",myl)输出结果：before changeint: 2after changeint: 2before changelist: [10, 20, 30]changelist: [10, 20, 30, ['hello', 1, 34]]after changelist: [10, 20, 30, ['hello', 1, 34]]

def print_favitor(name):if(name == "吕布"):print("认爹狂魔")elif(name == "曹操"):print("别人的老婆")elif(name == "刘备"):print("接着奏乐接着舞")else:print("目前还没收集到相关资料")def do_work(name1,name2):if(name1 == "曹操") and (name2 == "关羽"):return "华容道"elif(name1 == "周瑜") and (name2 == "诸葛亮"):return "赤壁"def mycalc(a, b):return a+b, a-b, a*b'''使用下面的if判断来表示脚本开始执行的位置
'''
if __name__ == "__main__":print("请输入三国人物1：")per_name = input()print("请输入三国人物2：")s_name = input()#print_favitor(per_name)#ret = do_work(per_name, s_name)#print(ret)(mysum, mysub, mymul) = mycalc(3,4)print(mysum, mysub, mymul)

参数

以下是调用函数可以使用的正式参数类型：
       必需参数
       关键字参数
       默认参数
       不定长参数

必需参数：
必需参数须要以正确的顺序传入函数。调用时的数量必须和声明时的数量一样

关键字参数：
       关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值
       使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为python解释器能够用参数名匹配参数值。
       例：

            #可写函数说明def printme(str):"打印任何传入的字符串"print(str)return #调用printme函数printme(str = "hello world")#不按照顺序传递参数样例def printinfo(name, age):"打印任何传入的字符串"print("名字：",name)print("年龄：",age)return printinfo(age=50, name="Jack")

def mytest(name1, name2):print(name1,name2)'''关键字参数一旦给出，后面都必须按照关键字给如果使用关键字参数，可以不按照先后顺序给参数
'''
mytest(name2="张飞",name1="吕布")
mytest("曹操",name2 = "典韦")

默认参数：
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入age参数，则使用默认值：

        def printinfo(name, age = 35):print("名字：",name)print("年龄：",age)return #调用printinfo函数printinfo(age=50, name = "Jack")print("--"*30)printinfo(name="Rose")运行结果：名字： Jack年龄： 50------------------------------------------------------------名字： Rose年龄： 35

不定长参数：
需要一个函数处理比当初声明时更多的参数。这些参数叫做不定参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args], *var_args_tuple):
           "函数_文档字符串"
           function_suite
           return [expression]

加了星号*的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

例：

        def print_info(arg1, *vartuple):"打印任何传入的参数"print("输出：")print(arg1)print(vartuple)print_info(70,69,88,66,78)结果输出：输出：70(69, 88, 66, 78)

'''第一种不定参可以不指定变量名
'''
def myprint(arg1, *vartuple):print(arg1,vartuple)'''第二种不定参，必须指定变量名
'''
def myfunc(arg1, **dictvar):print(arg1, dictvar)myprint(3,"hello",8,9,3.14,{'姓名':'时迁','职业':'小偷'})
myfunc(4,text="Jack",mydic={'名字':"孙二娘","别称":"母夜叉"},color="red",speak="give you color see see")

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

还有一种就是参数带两个星号**基本语法如下：
           def functionname([formal_args], **var_args_dict):
               "func_descript"
               function_suite
               return [expression]

例子：

            def print_info(arg1, **vardict):"打印任何传入的参数"print("输出：")print(arg1)print(vardict)print_info(1, a=2, b=3)输出结果：输出：1{'a': 2, 'b': 3}

声明函数时，参数中星号*可以单独出现，例如：

        def f(a,b,*,c):return a+b+c

如果单独出现星号*后的参数必须用关键字传入

        def f(a,b,*,c):return a+b+c#f(1,2,3)    #这样会报错ret = f(1,2,c = 3)    #正常print(ret)输出结果：6

匿名函数：
   python使用lambda来创建匿名函数。
   所谓匿名函数，意思是不再使用def语句这样的标准形式来定义一个函数。
   lambda只是一个表达式，函数体比def简单很多。
   lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
   lambda函数拥有自己的命名空间，且不能访问自己函数参数列表之外或全局命名空间里的参数。
   虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数式不占用栈内存从而增加运行效率。

语法：
lambda函数的语法只包含一个语句，如下：
lambda[arg1[,arg2,...argn]]:expression

例子：

  #定义一个sum的匿名函数sum = lambda arg1, arg2: arg1 + arg2#调用sum函数print("相加后的值为：",sum(10,20))print("相加后的值为：",sum(20,20))输出结果：相加后的值为： 30相加后的值为： 40

'''3.8版本以后才能用
'''
def mytest(a,b,c,/,d,e,f,g,h):print(a,b,c,d,e,f,g,h)'''
print("这是一个lambda表达式")
sub = lambda a,b:a-b
#没办法使用ret去接lambda表达式的返回值
#ret = sub(3,4)
print(sub(3,4))
'''

return语句
return [表达式]语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值地return语句返回None

强制位置参数：
python 3.8新增了函数形参语法/用来指明函数形参必须使用位置参数，不能使用关键字参数的形式。
以下的例子中，形参a和b必须使用指定位置参数，c或d可以是形参或关键字形参，而e或f要求为关键字形参：

def f(a,b,/,c,d,*,e,f):print(a,b,c,d,e,f)这个方法是正确的：f(10,20,30,d=40,e=50,f=60)使用下面的方法会发生错误：f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

打包，导包

导包的格式：
from 文件夹/包名 import 类名/方法名 as 新名字

from tkinter import Tk as tkroot = tk()
root.geometry("300x300")
root.title("导包")
root.mainloop()

#from mypackage.mythree_country import zhuge as le
from mypackage.mythree_country import *#从mythree_country文件中所调用的函数
#le()
dong_wu()
cao_wei()

python-----＞第二天，数据类型，三种基本结构，函数，文件操作，打包、导包相关推荐

读取Java文件到byte数组的三种方式及Java文件操作大全(包括文件加密,String加密)
读取Java文件到byte数组的三种方式 package zs;import java.io.BufferedInputStream; import java.io.ByteArrayOutputSt ...
python中常见的三种选择结构_在Python中,实现多分支选择结构的最佳方法是
在Python中,实现多分支选择结构的最佳方法是答:if-elif-else 绘制建筑平面图时,被剖切的墙用线绘制,定位轴线用线绘制答:粗实细点画智慧职教: 下列关于书写住院病历的叙述不正 ...
python 如何将虚拟环境的项目的所有.py文件的import导包汇总到requirements.txt文件 (pipreqs)
参考文章: pipreqs - Generate requirements.txt file for any project based on imports 作用: 能快速汇总所需安装的包然后批量安 ...
Python登录注册页面（用字符串，组合数据类型，程序三种基本结构）
1.代码代码如下: import re #导入re包while True:print('---------------欢迎来到图书馆借阅系统----------------')print('---- ...
python程序的三种基本结构是_Python程序设计实验五- 综合运用三种基本结构进行程序设计...
安徽工程大学 [Python程序设计]实验报告班级 :物流192 姓名:刘娇阳学号:3190505213 成绩: 日期:2020.4.24 指导老师 :修宇 [实验名称]实验五综合运用三种基本结 ...
python综合程序设计-Python程序设计实验五：综合运用三种基本结构进行程序设计...
安徽工程大学 Python程序设计实验报告班级:物流192 姓名:李心悦学号:3190505218成绩: 日期:2020. 4.26 指导教师:修宇 [实验名称] 实验五综合运用三种基本结构进行 ...
python综合实验报告_Python程序设计实验报告五：综合运用三种基本结构进行程序设计（综合性实验）...
安徽工程大学 Python程序设计实验报告班级物流191 姓名姚彩琴学号3190505129 成绩日期 2020.4.22 指导老师修宇 [实验名称]综合运用三种基本结构进行程序设计(综合性实 ...
python语言的三种基本结构_Python语言基础分支语句、循环语句.PPT
* * 循环结构回顾 for循环 for 循环作为编程语言中最强力的特征之一 Python可以使用for语句循环遍历整个序列的值 for循环所做的概括为一句话: 于- 其中的每一个元素,做-事情 * ...
python三种结构_Python基础05 三种基本结构选择结构
作者:玉树[林]风欢迎转载,也请保留这段声明. 程序的三种基本结构顺序结构代码按照编写的顺序,自上而下逐行运行.如下图所示. 代码按照A->B->C的顺序执行选择结构代码运行到选 ...

python-----＞第二天，数据类型，三种基本结构，函数，文件操作，打包、导包