Python语法统计

Python语法统计

1、 print（’ ’）关键字打印功能

2、 变量名字是随意起的可以给它赋值变量名是由下划线、数字、字母组成的，数字不能作为开头，其实这个变量就是可以储存值的一个罐子

例如：M=（’hello world’）这是给值起了个名字Print(M)然后再把这个变量名打印出来也就是把变量名里的值打印出来赋值是用=来赋值.
变量的类型有：
Number（数字）
string（字符串）
list（列表）
set（集合）
tuple（元祖）
dictionary（字典）

3、 list列表是用[]义的，列表的内容可以用变量名打印出来，就是把这个列表赋值给变量名，列表可以是多个值，

例如：list=[12,45,58,69,85,89]只是数字列表
List=[‘ ‘,45,’ ‘,58]可以组合字符串用引号引起来
List是数学意义上的有序集合，可以随时添加和删除，修改其中的元素（列表里的数据称为元素）也就是说列表是有序排列的，称为索引，索引是从0开始排序的，比如列表的第一个元素索引号就是0，第二个就是1，对于Python来说list是一个动态语言，所以它中的元素并不要求是哪个类型的数据，它可以是任何类型的数据组合也可以，
一个元素都没有的列表就是一个空的list

4、 首字母大写title();例如：print（变量名.title（））；

5、 全大写upper（）；同上

6、 全小写lower（）；同上

7、 Print不光打印字符，也可以运算，运算符有+、-、*、\加减乘除都可以

如：print（3+2）;会等于5这是数字运算也可以字符运算
如：print（’hello’+’world’）;会打印出hello world

8、 如果字符串内容有点长我们也可以换行‘/n’，也可以添加‘/t’空格

9、 说了加空格当然也有减空格的；

Print（变量名.rstrip）这个是去右边的空格的
Print（变量名.lstrip）这是去左边的空格的
Print（变量名.strip）这是去全部的空格的

10、给列表添加元素

表名.append（新元素）append（）是默认给列表最后添加元素
指定位置添加元素

表名.insert（索引号，新元素）如：是0新元素会在列表第一个之前的索引0会自动往后移变成索引号1

11、除列表：del 表名;整个表就都删了

        del表名[索引号]可以删除指定的索引所对应的元素
还有删除列表里的元素的也可以使用pop（）；

表名.pop（）;pop（）是默认删除列表最后一个元素的，你在括号里填-2是删除倒数第二个元素；用pop删除的元素还可以赋值给一个变量名以便以后拿来用

12、修改列表元素如：表名[索引号]=新元素 给指定索引换新元素

13、查看列表里有多少数据用len；如：print（len(表名)）；

14、给列表排序；如：print(sorted(表名))这个是正序 字母的话是用（a,b,c,d）来排序的

给列表倒叙；如：表名.sort(reverse=True) ;print(表名);倒叙关键词写在打印前面，倒序好了再进行打印

15、给列表换新名字也是循环，循环也是给列表换行，方便查看

如：for 新名（变量名）in 旧的列表名

16、创建一个整数列表；整数关键字range

首先创个空表；
 表名=[]
For 变量名 in  range (1,1000)；
表名.append（变量名）给空表添加1到1000的数据，再赋值给变量
Print（变量名）只会显示1到999的数据，因为插入的数据是包头不包尾的，

17、创建整数列表，另一个版本；

第一个参数表示从几开始，第二个是到几结束，第三个表示每次增加几

    表名=[]
For 变量名 in  range（2,45,2）数字时随便写的
表名.append（变量名）
Print（变量名）

18、切片（处理列表中的一部分称为切片）；

从另一个表取值如：number[1,1000]，这表是1到1000的数据
Number1=number[30:300]；从number表里取走30到300的数据并赋值给number1
首先看列表的长度      也可以取[:300] 就是从0到299的数据
Print（len(number1)）      [30:]就是从30到列表最后都会显示
获取列表的最后一个元素   切片是包尾不包头
Print（number1[-1]）括号里是索引号哦-1就是最后一个哦
列表切片元素是字符或字母，是按索引号切片

19、创建元祖列表

元祖列表和list非常相似，但是元祖一旦创建是不能修改的，没有pop，insert等方法，元祖和list的获取方式是一样的，但不能赋值给别的元素，元祖是用（）来定义的，元祖添加一个元素的时候后面要加‘，’要不它就不能是一个列表只是一个字符或数字，
Python ‘if’语句
1、 注意python 代码的缩进规则，具有相同缩进的代码被视为代码块
2、 If 语句后接表达式，然用：表示代码块开始，if 就是作为条件判断对错的 对（True）错（false）else，如果条件是对的会打印对的，如果是错的会走else，打印错的
如：列表=[1,2,3] 这表里有三个数据
For a in 表名：这里是冒号，看a 是不是在这个表里，下面给a赋值列表里的数据
If(如果)a 1；或2或3
Print（’True’）; 如果a1在表里会打印对的，如果不在这个表里打印错的，
Else(否则)： 这分两个代码块，如果对了会打上面的，错的打下面的；
Print（’False’）;
3、 多个条件判断
如果年龄在15到18之间应该是高中，多个条件之间使用and 连接，表示同时成立，
年龄=16;
If 年龄<18 and 年龄>15: 表达还是和上面一样的，只不过加了个条件连接，
Print(‘高中’)
Else:
Print(‘其他’);
4、 在列表中循环比较判断
表名=[12,15,89,87,16] 这个主要是正对数字列表，让这个表循环去比较 然后得出结果，

For a in 表名： 如果a 在这个表里 是<18 并且>15是青少年
   If a<18 and a>15    如果不是就打印其他的，
     Print(‘青少年’) ;
   Else:
     Print(‘其他’);

5、 多个条件判断使用or表示满足其中一个
变量名1=12；
变量名2=20；
If 变量名1<18 or 变量名2>15:
Print(‘青少年’)
6、 多个条件一个if不够用，可以加个elif 来进行加条件

小明=13岁
If（如果）小明年龄小于<14
Print（’小于14岁’）;
Elif 小明年龄<18：
   Print(‘年龄在14到18之间’);
Else :
   Print(‘大于18岁’);

7、 判断列表是不是空的，判断某个元素是不是在该列表中

列表=[12,13,16,56,45];
   A=12
If A in 列表;
 Print(‘在列表中’);
Else:
  Print(‘不在列表中’);

8、 迭代累加，用于计算总和；
A=0 首先是空表，给它插入整数1到100然后循环相加，

For B in range(1,101)；
  A+=B;(每次迭代累加)
 Print(A);

9、 字典
字典是一个键对值，每个键对应一个值，可以使用键来访问值，于键关联的值可以是数字也可以是字符，键和值之间用冒号隔开，一个字典里可以存放多个键对值，字典是用{}来定义的。
变量名={‘ ’:’ ’,’ ’:’ ’};同样和列表一样把字典存储到一个变量名里
10、键对值的查询
Print（ 表名[ ’键’]）会打印出相对应的值，
11、键对值的新增
表名[‘ 键’]=值 新增也是默认添加末尾
12、键对值的删除
Del 表名[‘键’] 和键相对应的值也会删除，
13、键对值的修改
表名[‘ 想要修改的键 ’]=’新值’
14、键对值的遍历也叫循环

For key,value in 表名.items（）;
  Print(key);  键和值分开循环打印，值如果是字符，数字组合，后面加类型打印
  Print(str (values));
只循环key
For key in 表名.keys()
  Print(key)
只循环value
For value in 表名 values()
  Print(value)

15、嵌套的定义
将一系列的字典存储在列表里，或者将字典存储在字典中成为嵌套
首先由多个字典
字典1={ }
字典2={ }
字典3={ }
字典4={ }
变量名=[字典1，字典2，字典3，字典4]；把多个字典赋值给一个变量同时把它变成一个列表
For 新变量名 in 变量名：首先从列表中取出一个字典去循环，然后查询它的键或值，
For key in 新变量名.keys();
Print(新变量名[key])；
16、在字典中存储列表
字典名={‘在这个字典里代表键’：[‘ ’,’ ’,’ ’],’代表第二个键 ’:[‘ ’,’ ’,’ ’] }
取字典里的一个键和值赋值给一个变量
变量名=字典名[‘键 ’];然后这个变量名就是一个列表了，
然后根据列表查询去查数据；print（变量也就是表名[索引号]）;
17、在字典中存储字典
字典名={‘ 在这个字典里代表键 ’：{’ ’:’ ’,’ ’:’ ’},’另一个键’：{‘ ’:’ ’,’ ’:’ ’} }
和上面一样从字典中取出一个键赋值给一个变量
变量名=字典名[‘ 键’]; 这个变量就变成了一个字典；
然后去循环这个字典进行查询；
For key,value in 变量名.items（）；
Print（key）
Print(value);
18、测试用户输入

19、函数input()的工作原理
让程序暂定一会运行，等待用户输入一些文本，获取用户输入后，Python将其存储在一个变量中，以便使用
变量名=input（’’） input里面可以存储别的东西
Print(‘’hello’+变量名’);
变量名=’随便都行’
变量名+=’随便道行’；
Print(变量名)；
根据用户输入的数字，判断是奇数还是偶数
变量名=11
变量名%=3；
Print（变量名）
20、while循环不会迭代list或tuple的元素，而是根据表达式判断循环是否结束
如要从0开始打印不大于n的整数

  N=20
  X=0
  While x<n  while 每次循环先判断x<n，如果为True,则执行循环体的代码块，否则退出循环，
    X+=x
    Print(x) x+=x会让x 不断增加，最终因为x<n不成立而退出循环
      如果没有这样一个语句，while循环在判断x<n的时候总是True,就会无限循环下去，变成死循环

21、使用退出循环表示返回到循环的开头，并根据测试条件再决定是否还要执行

     变量名=0
     While 变量名<10:
       变量名+=1;
     If 变量名%2==0：
       Print（'偶数’,+str(变量名)）;
        Continue
   Else :
    Print(‘奇数’+str(变量名))

22、测试while 用户输入q表示程序退出

    变量名1=True;
    While 变量名:
          变量名2=input(‘请输入q表示退出’)
         If  变量名2（input注释）!=’q’:
          Print(变量名2);
    Else:
       变量名1=False
       Print(‘退出程序’)

23、使用关键字来退出循环
表示立即退出循环，不再运行while里面的代码可用于控制程序的流程

变量名=0；
 While 变量名<10：
    变量名+=1;
    If 变量名%2==0：
       Print(‘偶数’+str(变量名));
        Break
 Else:
     Print(‘奇数’+str(变量名))；

24、函数（方法）
带有名字的代码块，完成具体的工作，见名知义

   定义函数的关键字def 函数名（）：
        Def 函数名（）无参数的函数（方法）
      Print（'hello word ’）;
    实参（实际的参数）
    调用函数时传递给函数的实际信息，就是给形参赋值
    形参（形式参数）
      函数完成工作所需要的一项信息
    如：def 函数名(a,b):
        变量名=a+b;
         Print(c)
    If_name_==’_main_’:这个是固定的是给形参赋值，
         函数名（2,3）

** 25、计算加减乘除的函数，a和b 代表具体的数值，c代表运算符 **

    Def 函数名(a,b,c);
     If c==’+’或==’-’或==’*’或==’/’  
          Print(a+b)或….
    Else:
       Print(a%b);

26、参数的传递
位置实参：在你调用函数或者方法的时候python 必须将函数的每一个实参都关联到函数定义的一个形参中，为此最简单的关联方式是基于实参的顺序的；
关键字实参：产地给函数的名称-值，关键词实参不考虑实参的顺序
参数的默认值：给该参数指定一个默认的值，默认值的参数必须放到最后

  如：def 函数名（a,b,c=’男’）;
     Print(a+b+c);
     If_name_==’main’:
     函数名（’张三’,’18岁’）;

27、参数可选也必须放到最后

    Def 函数名（a,b,c,d=’’）
     If d==’’;
      Return(a+b+c);
    Else:
      Return(a+b+c+d);

28、参数的个数是任意的

Def 函数名（*cc）：*代表了没有东西，任意
For 变量名 in  cc:
      Print(变量名);
    If_name_==’main’:
      函数名（12,15,46,78,89,89）;没有固定里面填多少数据都可以

29、位置参数和任意参数一块使用
Def 函数名（a,ac）：
Print（a）
For c in ac :
Print(str©);
** 30、关键词参数和任意参数*

    Def 函数名(a,b **c):
    Print(a);
    Print(b);
   For key, value in c.items():
     Print(key);
    Print(value);

31、调用以.py 结尾的文件的方法
From 文件名称 import 函数名，
32、模块名import 指定函数
Import 文件名 as 别名 导入整个模块as 代表模块的别名
**33、class 分类 **
，比如有三个类，有人，有大象，有冰箱，实现打开冰箱门，把大象放进去，关闭冰箱门，
如：

class  大象（）
       Def _init_ (self,tizhong,nianling):
          Self.tizhong=tizhong
          Self.nianling=nianling
       Class ren();
         Def _init_(self,name,nianling):
          Self.name=name
          Self.nianling=nianling
       Del open(self):
         Print(self.name+’打开冰箱门’);
       Def close(self):
         Print(self.name+’关闭冰箱门’);
       Def into bingxiang(self,weight,time,size):
      Print(self.name+’花了：’+str(time)+’分钟把体重为：’+str(weight)+’的大象放了尺寸是：’+str(size)+’的冰箱里面’)
        Class bingxiang():
         Def _init_(self,size):
          Self.size=size
       If_name_==’_main_’:
        Ren= ren (‘张三’,25)；
        Daxiang=daxiang(100,5880);
        Bingxiang=bingxiang(6000);
        ren.open();
        ren.intlbinxing(1800,10,bingxiang.size)
        ren.close()

34、 冒泡排序（从大到小）

       冒泡排序：原理：比较相邻的两个元素将值大的元素交换的前面
            思路：一次比较相邻的两个元素，将大数放到前面，小数放后面，即在第一趟比较的时候首先比较第一个和第二个数，将小数放后面，
    大数放到前面然后比较第二个和第三个，将小数放到最后面，大数放到最前面，如此反复，一直到比较最后两个数
    第一趟比较完毕之后最后一个数字一定是最小，因此在第二趟中比较的时候最后一个数不参与比较，
    第二趟比较完毕之后倒数第二个一定是这一组最倒数第二最小的，因此第三趟比较中不参与比较，
     …………其他不写了，一次类推
    每次比较的次数减少一次

编程语法如：

     列表名=[45,13,56,89,45];
     变量名=len(列表名)；查看有多少数据；
     For I in range(变量名)：控制次数
        For j in range(变量名-1)：交换次数 j 代表下标
          If (列表名[j])<列表名[j+1]：
           变量名=列表名[j]; 把下标赋值给一个变量
           列表名[j]=列表名[j+1]；
            列表名[j+1]=变量名
    Print(列表名);

类

  class car():
    def __init__(self,make,model,year):
        self.make = make;
        self.model  = model;
        self.year  =year;
        self.lichenshu = 0; #默认值
    def get_describe(self):
        '''定义一个汽车的描述'''
        return '这辆车的厂家是：'+self.make+'品牌是:'+self.model+"生产年份是："+str(self.year)+"里程数是："+str(self.lichenshu);

    def addlichenshu(self):
        '''修改默认值'''
        self.lichenshu+=100;
    def addUserchenli(self,userli):
        '''修改指定的值'''
        self.lichenshu +=userli;
    def volitalichen(self,lisheng):
            '''添加了一个里程的校验'''
            if lisheng < 0:
                return ;
            else:
                self.lichenshu +=lisheng;
    if __name__ == '__main__':
        car =Car('上汽集团','大众',2017);
        desc = car.get_describe();
        car.lichenshu=100;
        car.year=2018;
        print(desc);
       # car.addlichenshu();
        print(car.lichenshu);
        print(car.get_describe())

** 35、 #面向对象的特征：继承 **
#通过继承的创建的新的类成为子类或者派生类 被继承的类成为 父类或者超类 基类
#继承可以实现现有类的所有功能，并且无需重编别写原来的类并对这些功能进行扩展

class person():
    def __init__(self,name,age):
        self.name = name;
        self.age= age;

    def get_describe(self):
        return "我的名字是:"+self.name+"年龄是:"+str(self.age);
class students (person):

    def __init__(self,name,age):
        super(students,self).__init__(name,age)
if __name__ == '__main__':
    stu = students('杨丽',25);
    print(stu.get_describe()); Administrator(0C9D92C05DE9) 22:47:37
class person():
    def __init__(self,name,age):
        self.name = name;
        self.age= age;

    def get_describe(self):
        return "我的名字是:"+self.name+"年龄是:"+str(self.age);
class students (person):

    def __init__(self,name,age,score,cla_):
        super(students,self).__init__(name,age)
        self.score =  score;#给子类增加额外的属性
        self.cla_ = cla_;#给子类增加额外的属性

    def get_describe(self):
        '''z子类继承父类方法并且重写父类的方法'''
        return "我的名字是:"+self.name+"年龄是:"+str(self.age)+'成绩：'+str(self.score)+"班级是："+self.cla_;

if __name__ == '__main__':
    stu = students('张彪',25,100,'北斗星一班');
    print(stu.get_describe1());

** 36、 文件的读取**

#使用文件的相对路径读取文件
#with open('../file/test.txt')  as file_object:
 #  content= file_object.read();
  # print(content);
#使用绝对路径读取文件(练习题)
#read()参数 表示读取文件的长度
#with open('test11.txt') as file_object:
 #   content =file_object.read(4)
#    print(content);
Administrator(0C9D92C05DE9对话) 14:49:48
#文件处理类
class readUtil():
    def __init__(self,file):
        self.file = file;

    def readfile(self,file):
        '''读取文件的方法'''
        with open(file) as file_object:
            content = file_object.read();
        return content;
Administrator(0C9D92C05DE9对话) 15:11:59
#一行一行的读取
with open ('test11.txt') as file_object:
    count = 0;
    for line in file_object:
        count+=1;
        print("第"+str(count)+"行的数据是:"+line);

#读取文件的内容并写到列表中
number_1=[];
with open ('test11.txt') as file_object:
    for line in file_object:
        number_1.append(line.strip());

    print(number_1);



print("==================")
#number = [];
with open('test11.txt') as file_object:
    number.append(file_object.readlines());
    #content = file_object.readlines();
    #print(content)
    print(number);
 
 
print('数据类型在数据结构中的定义是一个值的集合以及定义在这个值集上的一组操作')
print('变量是用来存储值的所在处；他们有名字和数据类型')
print('python 的数字也有四种数据类型有整数（int），浮点数（float），布尔值（bool），复数（complex）');
print('我们发现测量出的233整数类型（int）233.0是浮点数类型（float），’233‘（注意有单引号）是字符串类型（str）')
print(type(233))
#判断233的类型
print(type(233.0))
print(type('2.33'))
#判断是不是正确的类型
print(isinstance(233,int));
print(isinstance(233,float));
print(isinstance('23.3',str));
print(0b1001110)
233==233.0
print(-2.33-5.7j)
print(-2.33-5.7j)
a=1
b=2
c=3
print(c);
print(45678+0x12fd2);
print('learn Python in imooc');
if 0xff==255:
    print(True);
else:
    print(False);
print("======================================================快乐的分割线========================================================")
#print('hello world')

#定义函数
def prikd(a,b):
    c= a+b;
    print(c);
if __name__ == '__main__':
   prikd(6,4);
#换行
s=('Python was started in 1989 by "Guido".\nPython is free and easy to learm.')
print(s);
print (r''''\"To be,or not bo be":that is the question .\nwhether it\'s nobler in the mind to suffer'.''');
print(2.5+10/4);
print(True or False);#布尔值用（and，or，not）进行运算
a='python';
print('hello,',a or'world');
b=''
print('hello,',b or 'world');
list=['Adam',95.5, 'Lisa',85, 'Bart',59];
#删除与替换，添加，pop默认删除最后一个
list.append('pruie');#默认添加到最后一个
list.append(70);
A=list.pop();#pop默认删除列表最后一个并且可以赋值给一个变量以便调用
B=list.pop();
print(list);#list是一个有序列表
print(A);
print(B);
tuple=(0,1,2,3,4,5,6,7,8,9);#是元祖列表数据是不可变的
print(tuple);
t=('Admin',)
print(t);
yangli=26;
#计算机之所以能做很多自动化的任务，因为它可以自己做判断条件
#if else 如果不等于if，就等于else
if yangli>26:
    print('还是少女');
else:
    print('娘们');
#差点就出错了，part 的成绩是75，如果>60是passed,如果<60是不及格。
part=75;
if part>60:
    print('passed');
else:
    print('不及格');
ta=20;
if ta<=18:
    print('teenage');
else:
    print('adult');
#多个条件判断
优秀生=70
if 优秀生<90 and 优秀生>=60:
    print('中等生');
elif 优秀生<30:
    print('不及格');
else:
    print('0');
score=85;
if score>90:
    print('excellent');
elif score>80:
    print('good');
elif score>60:
    print('passed');
else:
    print('failed');
#求大于60分的平均值
L=[59,92,59,40,70,68];
sum=0.0
N=0
for C in L:
 if C>60:
  N+=1#迭代累加
  sum+=C#迭代累加
print(sum/N);
#求平均值
n = [75, 92, 59, 68];
sum = 0.0;
b=0;
for name in n:
   if name>=60:
    b+=1
    sum += name;
print(sum / b);

class daxiang():
    def __init__(self,age,weight):
        self.age = age;
        self.weight = weight;

class person():
    def __init__(self,name,age):#定义：前后两个下划线__init__ 一个必须的参数self必须在最前面 后面再定义其他的参数
        self.age = age;
        self.name = name;

    def open(self):
        '''打开冰箱门'''
        print(self.name+"打开冰箱门");

    def close(self):
        '''关闭冰箱门'''
        print(self.name+"关闭冰箱门")

    def intobinxing(self,weight,time,size):
        '''把大象放冰箱'''
        print(self.name+"花了："+str(time)+"分钟把体重为:"+str(weight)+"的大象放了尺寸是:"+str(size)+"的冰箱里面");

class binxing():
    def __init__(self,size):
        self.size = size;

if __name__ == '__main__':
    person = person('张三', 25);
    daxiang = daxiang(100, 5800);
    bixin = binxing(200);
    person.open();
    person.intobinxing(1800,10,bixin.size);
    person.close();
#1-100循环求奇数的和，有两个条件，一个是不能大于100，一个是除于2没有余数
sum=0;
x=0;
while True:
    x = x +1 #从1开始加直到一百
    if x>100:
        break#如果大于100会停止循环
    if x % 2 != 0:#除于2没有余数就是求奇数
        sum += x#sum=sum+x就是每次x相加会再加一次
        continue#会再回去循环
print(sum);
sum=0;
n=0
x=0;
while True:
    x=x+1
    if x >100:
        break
    if x %2!=0:
        sum+=x;
        n+=1
        continue;
print('奇数总和', sum);
print(n)
print(sum)
#1,2,4,8，以这种规律求前20项的总和
sum=0
x=1
n=1
while True:
   x=2**(n-1)
   x=x+1
   if n>20:
      break
   sum+=x
   n+=1
   continue
print(sum);
sum=0;
x=1;
n=1;
while True:
    x = 2 ** (n - 1);
    x=x+1
    if n>20:
        break
    sum+=x
    n+=1
    continue
print(sum)
#合并循环
x=[];
for y in range(1,11):

 for A in range(1,11):
  if y<A:
   print('y'+'A')
#冒泡排序一个数字一个数字去比较
N=[89,45,65,23,52,56];
c=len(N);
for a in range(c-1):
    for b in range(c-1):
     if(N[b])<N[b+1]:
         m=N[b];
         N[b]=N[b+1];
         N[b+1]=m;
print(N)
分几个对象去定义方法
class daxiang():#类
    def __init__(self,mianji,nianling):#定义值
        self.mianji=mianji;
        self.nianling=nianling;
class bingxiang():
    def __init__(self,size):
        self.size=size;
class pepo():
    def __init__(self,name,nianling):#定义方法
        self.name=name;
        self.nianling=nianling;
    def open(self):
        print(self.name+'打开冰箱');
    def coles(self):
        print(self.name+'关闭冰箱门');
    def intobingxiang(self,mianji,size):
        print(self.name+'把大象放进冰箱');
if __name__ == '__main__':
    daxiang=daxiang(200,5800);
    bingxiang=bingxiang(6000);
    pepo=pepo('小王',25);
    pepo.open()
    pepo.intobingxiang(5800,bingxiang.size)
    pepo.coles();
#使用绝对路径读取文件
with open('test.txt') as a:#首先找到文件的所在，顺便改个名字；
      b =a.read(5) # 读取文件数据，把读出来的数据赋值给一个变量
      print(b);
#文件处理,类
class readUtil():
    def __init__(self,file):
        self.file = file;

    def readfile(self,file):
        '''读取文件的方法'''
        with open(file) as file_object:
            content = file_object.read();
        return content;
if __name__ == '__main__':
   n= readUtil.readfile(0,'test.txt');
print(n);
#一行一行读取
with open ('test.txt') as n :
    s=0;
    for b in n:
        s+=1;
        print('第'+str(s)+'行的数据是：'+b);
#读取文件的内容并写到列表中
a=[];
with open ('test.txt') as c:#首先找到文件 并改名称
    for m in c :  # 循环文件内容并赋值给一个变量，
        a.append(m.strip());#然后给空列表填入文件的数据
    print(a);
#或者：另一个方法
a1=[];
with open ('test.txt') as c:
    a1.append(c.readlines());

    print(a1);
 

#文件的写入
#w表示写入模式，a表示追加模式,r表示读取模式

#with open (ad,'w') as bd:
 #   for p in range(1,50):
  #      bd.write(str(p)+'\n');
#print('写入完成');
#用input 输入往文件添加内容；

def defc(self,women):
    with open(women,'a')as hhh:
        while True:
            name=input('请输入'+'\n');
            if name=='q':
                break
            else:
                hhh.write(name+'\n');
if __name__ == '__main__':
  ss= defc(0,'test1.txt');
print(ss)