第一天
# # 这是一个单行注释
#
# print('摸头') # 这是一个单行注释
#
# '''
# 这是一个多行注释，用三个引号括起来
# '''
#
# """
# 或者三个双引号
# """
#
# # Python中代码块不使用大括号{}来控制类，主要采用：以及缩进来区分代码的层次
#
# if 1 == 2:
# print('hello wold')
# else:
# print('world hello')
#
# # Python语言对于缩进要求非常严格，同一个级别的代码块必须缩进量相同
#
# # 同一个级别的代码块还必须保证缩进方式相同，同为tab或空格缩进
#
# -------------------------------------# 编码规范----------------------------------
# '''
# 1、不能在行尾加分号；
# 2、每行的字符数量最多不能超过80个，如果超过，建议使用小括号将多行的内容隐式连接起来
# 3、每个import只能导入一个模块
# '''
#
# ------------------------------------- # 编码规范------------------------------
# '''
# 1、程序代码超过一行，可以在每一行的结尾添加反斜杠\继续下一行
# 2、如果是以小括号，中括号，大括号包含起来的语句，不必要使用反斜杠\就可以分成数行；
# 3、如果要将数行表达式写成一行，只需在原来最后一行的结尾添加分号；
# '''
# a = 1
# if 100 < a < 100 and 1 <= b <= 10 \
# and 1000 <= v <= 1000 and 1000 <= d <= 4:
# print('q')
# else:
# print('a')
#
# a = 'apple'; b = 'banana'; c = 'cheese'
#
# #Python语言是区分大小写的;
#
# #python不必声明变量的类型
#
# #每个变量使用前必须进行赋值；
#
# a = b = 666
# print(a,b)
# print(id(a), id(b))
#
# x, y, z = 1, 2, 'hello'
# print(x, y, z)
#
# print(1 + True)
#
# a = 'apple'
# b = 'banana'
# fruit = ['apple','banana','cheese']
# if (a in fruit):
# print('a in fruit')
# else:
# print('a not in fruit')
#
#
#
# "模拟银行自主取款机"
# print("请输入你想取款的金额")
# # a = input()
# # a=int(a)
# a=int(input())
# print("你本次取款金额为:%d" % a)
# if a % 2 == 0 and a % 3 == 0 :
# print("nice")
# else:
# print("bad")
# cnt=0;
# for x in range(1,5):
# for y in range(1,5):
# for z in range(1,5):
# if x != y and x != z and y != z:
# print(x , y , z)
# cnt=cnt+1
# print("it has %d" % cnt)
#
# a=10
# while a>0:
# a=a-2
# if a==6:
# print('nice')
# continue
# # break
# print("a=", a)
#
# a = 'apple'
# cnt = 0
# cout = 0
# print("please input the char you choose")
# N = str(input())
# for i in a:
# cnt=cnt+1
# for i in a:
# cout = cout + 1
# if i == N:
# print('Congratulation!find it,at %d' % cout)
# break
# if cout == cnt:
# print('sorry,dont find it!')
# if cout == 1:
# print("you get 10000 dollor")
# elif cout == 2:
# print("you get 1000 dollor")
# else:
# print("you get 0 dollor")
# ------------------------------------------序列----------------------------
# 采用负数为索引的时候，是从-1开始的，也就是最右边的元素的下表为-1；
# s=[start : end : step]
# # 序列相加
# x = [1, 2, 3] + [2, 3, 4] + [3, 4, 5]
# # !!! 注意集合和字典不支持相加
#
# # 序列相乘
# x = [1, 2, 3] * 3
#
# # 检查序列中的成员 value in sequence 当元素是序列的成员的时候返回True，否则返回False
# x = [1, 2, 3]
# y = 1
# print(y in x) # 检查是否在
# print(y not in x) # 检查是否不在
#
# # ---------------------------------------------集合--------------------------
# # 创建集合的时候用大括号{}来包含其元素
# books={'apple','banana','peach'}
# # 集合的输出是无序的，不会按照赋值的顺序进行输出，如果集合中有重复的元素，就会自动删除；
# books = {'apple','banana','apple'}
# print(books)
# # 如果创建一个空集合，必须使用set()函数，books=set()
# # 集合类型的常见操作
# a = {1,2,3}
# x = 2
# a.add(x) # 集合添加元素,如果元素已存在，则不进行任何操作
# b = {'apple', "banana", 'peach'}
# b.add('apple')
# print(b)
# b.remove('apple') # 移除元素，移除不存在的元素将会报错
# print(b)
# len(a) # 计算集合元素个数
# a.clear() # 清空集合
# print(a)
#
# # ----------------------------------------------列表类型----------------------------------
# # 列表就是写在中括号【】之间，用逗号，分隔开的元素
# s = [1, 2, 3, 4]
# !!! 在不知道列表长度的时候，可以采用负数作为索引，通过将索引指定为-1.可以让Python返回一个列表最后的元素；
w = [1, 2, 3, [1, 2, 3, 'banana'], 'apple'] # 列表中的元素可以是不同类型,列表中的元素可以是另外一个列表
# print(w[4]) # 列表的序号是从0开始
# print(w[-1])
# print(w.index(w[-1])) # 获得元素的索引值
# print(w[3][3]) # 列表是可以嵌套的
#
# w[1] = 'peach' # 改变列表的元素值
# print(w)
# del w[1] # 删除列表中的元素
# print(w)
# del w[:] # 删除所有的元素
#
# # 列表内置的函数
# print(len(w), max(w), min(w)) # 返回列表的长度 !!!使用max与min的时候列表内的元素的类型必须一致
# # 列表的方法
# dir([]) # 可以查看内置的列表的方法
#
# x = [100, 200, 300, 400]
# x.append(500)
# x.clear()
# a = [100, 'apple', 0.9]
# b = a.copy()
# a = [100, 200 ,300, 300, 400]
# print(a.count(300)) # count方法针对列表对象中的相同元素值value计算其数目
# a.extend(['apple', 'banana', 'peach']) # 将列表【】加到此列表中
# print(a)
# print(a.index('apple')) # 返回列表元素值apple的索引值
# x = [1, 2, 3, 4]
# x.insert(3, 'apple') # 在列表索引3前插入新元素
# print(x)
#
# x = [1, 2, 3, 4, 5, [5, 6, 7, 5]]
# x.pop(1) # 删除列表中index为1的元素，如果没有指定index的值，则默认删除最后一个元素
# print(x)
# x.pop()
# print(x)
# x = ['apple', 2, 'read', 4, 5]
# x.remove('apple') # 删除列表中元素值为apple的元素
# print(x)
# x = [1, 2, 3, 4, 5]
# x.reverse() # 将列表对象中的元素颠倒排序
# print(x)
# x = [3, 4, 2, 1]
# x.sort() # 将列表中的元素按照大小顺序排列
# print(x)
# a = 'apple'
# a = list(a)
# print(type(a), a)
# # ---------------------------------------元组--------------------------------------------------------
# # 与列表相比，元组对象不能更改，同事元组使用小括号，列表使用中括号
# # 元组属于有序对象，可以使用数字作为索引，元组与列表类似，差别在于元组对象不能新增，修改与删除
# a=(1,2,3,4,5)
# print(a)
#
# print(a[1])
#
# # 元组赋值时可以省略小括号，直接将元素列出
# a=1,2,3,4
# print(a)
# print(type(a))
#
# sname=('tim','sod','asd','fvc')
# for name in sname:
# print(name,end='--')
#
# #删除元组内的对象
# a=('hello world','hey serry','good morning')
# print(a)
# a=a[0],a[2] #注意，元组内的元素不能进行修改和直接删除，但是我们可以通过重新赋值的方法间接达到删除的效果
# print(a)
#
# #删除整个元组
# x=(1,2,3)
# del x
# print(x) #会显示报错，因为元组x已经被删掉了
# #元组的内置函数
# a=(1,2,3,6,7,8)
# print(len(a))
# print(max(a)) #元组中元素类型必须一致才能使用max,min
# print(sum(a))
第二天
# #-------------------------------------------------字典--------------------------------------------------
# """
# 字典使用大括号将元素列出。元素由键值key和数值value组成，中间用冒号：隔开；键值必须是字符串，数字或元组；这些对象是不可以动的；
# 数值可以使任意类型,字典元素排列没有一定的顺序，因为可以通过键值来取得元素
# """
#
# #创建字典的格式如下：字典变量={关键字1：值1，关键字2：值2，...}
# #在同一个字典内，关键字必须是不同的；
#
# x={'一班':'张小明','二班':'李雪丽','三班':'张小明'}
# print(x)
# print(x['一班'])
# #在获取字典中的元素值的时候必须确保输入的键值在字典中是存在的，否则Python会产生一个keyerror的错误
#
# #--------------字典的常用操作------------
# #修改字典中的元素值
# x={'一班':'张小明','二班':'李雪丽','三班':'张小明'}
# x['三班']='章长眠'
# print(x)
# #删除字典中的元素
# del x['三班']
# print(x)
# #定义字典键值时需要注意的问题
# '''
# 字典键值是不可以随便定义的
# 1.不允许同一个键值出现两次，创建时，如果同一个键值被赋值多次，那么只有最后一个值有效，前面重复的值都会被自动删除
# 2.字典键值不可改变，，所以可以用数字，字符串或元组充当，列表不行，如果用列表做键值，则会报错
# '''
# x={'一班':'张小明','二班':'李雪丽','三班':'张小明','一班':'苏和宇','二班':'刘素琴'}
# print(x)
# # x={['名称']:'冰箱','产地':'贵州','价格':'6500 '}
# # print(x)
#
# #字典的内置函数和方法
# #字典的内置函数len(),str(),type()
# len(x) #计算字典元素个数，即键值的总数
# print(len(x))
# str(x) #将字典元素转换为可打印的字符串形式
# print(str(x))
# a=str(x)
# print(type(x))
# print(type(a))
# print(len(a))
# cout=0
# for i in a:
# print(i,end='/')
# cout=cout+1
# if cout==len(a):
# print('')
# #字典的内置方法
# a=x.copy()
# a.clear()
# print(x.get('一班'))
# print(x.get('四班','不存在'))
#
# a=x.items() #使用字典中的元素创建一个由元租对象组成的列表
# print(a)
# a=x.keys() #使用字典中的键值创建一个列表对象
# print(a)
# print(x)
# x.popitem() #删除字典最后一个元素
# print(x)
#
# #制作火车票查询系统
# aa=['G15','C2065','295','G565'] #定义键的列表
# bb=['北京-上海','北京-天津','北京-重庆','北京-郑州'] #定义值的列表
# cc=dict(zip(aa,bb))
# print("欢迎进入火车票查询系统")
# print(cc)
# n=input('请输入你要查询的车次：')
# print(n+'次车的出发站和终点站是：',cc.get(n))
# #zip函数的使用
# a=[1,2,3]
# b=[4,5,6]
# c=['a','b','c','d','v']
# zipped=zip(a,b) #返回一个对象
# print(list(zipped)) #list转为列表
# zipped=list(zip(a,c)) #元素个数与最短的列表一致
# print(zipped)
# a1,a2=zip(*zip(a,c)) #与zip相反，*zip(*)可以理解为解压，返回二维矩阵式
# print(list(a1),list(a2))
# #dict()函数的使用
# a=dict() #创建一个空字典
# b=dict(a='a',b='b',c='c')
# c=dict(zip(['one','two','three'],[1,2,3]))
# d=dict([('one',1),('two',2),('three',3)])
# print('\n',a,'\n',b,'\n',c,'\n',d)
# #-------------------------------------------字符串---------------------------------------------
# #拼接字符串
# x='吸取黄鹤楼'
# y='白云前又有'
# print(x+y)
# #如果字符串和其他类型的数据进行拼接，将会报错，所以要想解决此类问题应将其转换为字符串型即可；
# num=1000
# # print(x+num)
# print(x+str(num))
# print(len('hello world!'))
# print(x[:],x[0],x[0::2],x[-1],x[-1::-2])
# -------------------------------------函数---------------------------------
# # 创建函数
# def sum(x, y):
# return x + y
#
#
# print(sum(1, 2))
# 参数传递
"""
形参与实参，函数调用中发生的数据传递是单向的，即只能把实际参数的值传递给形参，而不能把形参的值传递个实参，因此在函数调用的过程中
形参值发生改变的时候，实参的值不会因其改变而改变
在调用函数的时候，函数的参数就是形参，形参也就是形式上的参数，它代表参数，但是不知道是具体代表的什么参数，实参就是调用函数的时候的参数，
即具体的已经知道的参数；
在Python中，会根据实参类型的不同，进行值传递，可以分为将实参的值传递给形参和将实参的引用传递给形参两种情况，当实参为不可变对象时进行值传递；
当实参为可变对象的时候进行引用传递，他们之间的区别就是如果进行值传递，如果改变形式参数的值，实参的值不变，如果进行引用传递。如果改变形参的值
实参的值也会发生改变
"""
# def passon(a):
# print('原始值是：', a)
# a += a
#
#
# print('下面进行值传递')
# a='hello world!'
# print('函数调用前',a)
# passon(a)
# print('函数调用后',a)
#
# print('下面进行引用传递')
# a=['apple','banana','peach']
# print('函数调用前',a)
# passon(a)
# print('函数调用后',a)
# #必须参数
# #必须参数要求用户必须以正确的顺序传入函数，调用时的数量必须和声明的时候一样，按照位置排列
# def fruit(x,y):
# print('今日'+x+'的价格为：',y)
#
#
# fruit('banana',21)
#
# #关键字参数
# #用户可以直接设置参数的名称及其默认值，这个类型的参数属于关键字参数
# fruit('苹果',12.6)
# fruit(x='apple',y=12.6)
# fruit(y=12.6,x='apple')
# #默认参数
# def ns(name,score=66):
# print('姓名',name)
# print('得分',score)
# return
#
#
# ns('张飞',89)
# # 可变参数
# # 如果用户在声明参数时不知道需要使用多少个参数，就使用可变参数，可变参数不用命名
# def good(s, *args):
# print(s)
# for y in args:
# print('可变参数:', y)
# return
# # 加了星号*的变量名会存放所有未命名的变量参数，如果在函数调用的时候没有指定参数，他就是一个空元组
#
#
# print('不带可变参数')
# good('fridge')
# print('带两个可变参数')
# good('fridge', 'nice', 3866)
# print('带六个可变参数')
# good('冰箱', '洗衣机', 3886, '空调', 7800, '电视机', 8900)
# 从运算结果可以看出，用户无法预订参数的数目时。可以使用*arg类型的参数，*arg代表一个元组对象，在定义函数时，之定义两个参数，
# 调用时可以传入两个以上的参数，这就是可变参数的优势
#
# # 用户也可以以使用**arg类型的参数，**arg代表一个字典对象
# def goods(**args):
# print('名称=')
# for a in args.keys():
# print(a)
# print('价格=')
# for b in args.values():
# print(b)
#
#
# goods(冰箱=4500, 洗衣机=5600, 电视=7800)
#
#
# # 返回值
# # return语句用于退出函数，有选择的向调用方返回一个表达式，不带参数值的return语句返回none
#
# def sum(x, y):
# tm = x + y
# print('求两个数的和:', tm)
# return tm
#
#
# print(sum(12, 32))
#
#
# # 函数的返回值可以是多个,此时返回值以元组对象的方式返回
# def number(x, y):
# z = x
# x = y
# y = z
# return x, y
#
#
# print(number(1, 2))
# a, b = number(1, 2)
# print(a, b)
# 如果没有return语句，那么函数执行完毕也会返回结果，只是结果为none
# 变量作用域，全局变量和局部变量，如果要在函数内改变全局变量的话，就必须使用globle关键字
# x = 1
#
#
# def chx():
# global x
# x = 2
# return x
#
#
# print(chx())
# # 匿名函数
# # 所谓匿名函数，就是不再使用def语句这样的标准形式定义一个函数，Python语言程序中，使用lambda创建一个匿名函数
#
#
# def f(x, y):
# return x- y
#
#
# print(f(1, 2))
# fx= lambda x, y: x - y
# print(fx(1, 2))
# import math
# print(math.pi)
第三天
# # -----------------------------------------类-------------------------------------------
# class good:
# # 定义基本属性
# name = ' '
# factory = ' '
# # 定义一个私有属性，私有属性在类外部无法直接进行访问
# __price = 0
#
# # 定义构造方法,类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。
# def __init__(self, n, f, p):
# self.name = n
# self.factory = f
# self.__price = p
#
# def disgood(self):
# print('%s 生产的%s 质量不错，最新款的价格是%s元' % (self.factory, self.name, self.__price))
#
#
# # 例化类
# g = good('洗衣机', '云南科技', '4660')
# g.disgood()
# # 类的方法与普通函数只有一个特定的区别，就是它们必须有一个额外的第一个参数名称，按照惯例它们的名称是self
# # 类的私有属性实例如下：
# class JustCounter:
# __secretCount = 0 # 私有变量
# publicCount = 0 # 公开变量
#
# def count(self):
# self.__secretCount += 1
# self.publicCount += 1
# print(self.__secretCount)
#
#
# counter = JustCounter()
# counter.count()
# counter.count()
# counter.count()
# print(counter.publicCount)
# # print(counter.__secretCount) # 报错，实例不能访问私有变量
# # 类的私有方法实例如下
# class Site:
# def __init__(self, name, url):
# self.name = name #public
# self.__url = url #private
# print('test')
#
# def who(self):
# print('name: ',self.name)
# print('url: ',self.__url)
#
# def __foo(self): #private method
# print('this is private method')
#
# def foo(self): #public method
# print('this is public method')
# self.__foo()
#
#
# x=Site('Python学习','hello world')
# x.who()
# x.foo()
# # x.__foo()
第四天
# ----------------------------------------模块和包----------------------------------------
# 将模块中的代码编写在一个单独的文件中然后将其命名为模块名.py即可；
# 模块名不能与标准库，模块重名
# main.py
omport test
test.test_1(1)
test.test_2(1)
------------------------------------------------
# test.py
def test_1(i):
if i == 1:
print('num is equel 1!')
else:
print('i not equel 1!')
def test_2(i):
if i > 1:
print('i is higher than 1')
elif i == 1:
print('i is equal 1')
else:
print('i is lower than 1')
# -------------------------------------WEB网站编程-------------------------------------------
# 创建XML文件
# <?xml version="1.0" encoding="GB2312" ?> # 此为声明，XML声明必须作为XML文档的第一行，前面不行有空白，注释或其他处理指令；
# version属性不能省略，且必须排在第一位,指明所采用的XML版本号，值为1.0，该属性用来保证对XML未来版本的支持；encoding属性是可选的，
# 该属性指定文档的编码方式，即规定采用那种字符集对XML文档进行文档编码；常采用UTF-8和GB2312，如果没有使用encoding属性，则该属性默
# 认值为UTF-8，如果使用的是GB2312，那么文档必须使用ANSI编码保存，文档的标记内容只可以使用ASCII字符和中文；
# 注释以<!--开始, 以-->结束
# <开始标记>文本内容</结束标记>
# <?xml version="1.0" encoding="gb2312" ?>
# <!--这是一个员工信息表--> #这是一个注释
# <员工信息>
# <员工>
# <姓名>张三</姓名>
# <年龄>28岁</年龄>
# <学历>本科</学历>
# <员工>
# <员工>
# <名称>李萌</名称>
# <年龄></年龄>
# <学历></学历>
# <员工>
# </员工信息>
# ---------------------------Python解析XML----------------------------------
# 使用SAX解析XML
# 使用DOM解析XML
215
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
