文件打开的模式
#！/usr/bin/env python
# Author:hongjie.gao
# r模式是默认的模式。只读，文件不存在则报错
# f=open('a.txt',encoding='utf-8') # 默认以读的方式打开
# print(f.read())
# f.write('11111
') # 不可写
# print('====>',f.read()) # 读所有,读出来bytes类型，open函数把bytes类型decode（'utf-8'）=====>str
# print('====>',f.read())
# print(f.readlines()) #读所有，结果放入列表中
# print(f.readline(),end='') # 一次读一行
# print(f.readline(),end='')
# f.close()
# W:只写模式，如果文件存在则清空，如果文件不存在则新建
# f=open('a.txt',mode='w',encoding='utf-8')
# f=open('b.txt',mode='w',encoding='utf-8')
# print(f.read())
# print(f.write('1111
')) # 一定要自己加换行符
# print(f.write('2222
')) #unicode----encode--->bytes
# print(f.write('3333
'))
# l=['44444
','55555
','66666
']
# for line in l:
# f.write(line)
# print(f.writelines(['44444
','55555
','66666
','777777
']))
#
# print(f.writable()) # 是不是可写
# f.close()
# a:追加写模式(日志)：如果文件存在则把光标移动到文件末尾，如果文件不存在则新建
# f=open('c.txt','a',encoding='utf-8')
# f.write('3333333
')
# f.writelines(['555555
','666666
'])
# f.close()
# with open('a.txt',encoding='utf-8') as f:
# # # lines=f.readlines()
# # # for line in lines:
# # # print(line,end='')
# #
# # for line in f:
# # print(line,end='')
#
# with open('a.txt',mode='rt',encoding='utf-8') as f:
# for line in f:
# print(type(line),end='')
# with open('nb.png',mode='rt',encoding='utf-8') as f:
# pass
# b：以bytes的形式去操作文件内容,不转码,不能指定编码
# with open('nb.png',mode='rb',encoding='utf-8') as f: #不能带字符编码
# f.read()
# with open('nb.png',mode='rb') as f:
# print(f.read())
# with open('a.txt',mode='rb') as f:
# data=f.read()
# print(data.decode('utf-8'))
# with open('d.txt','wb') as f:
# f.write('哈哈哈哈哈hello'.encode('utf-8'))
#
# with open('d.txt','ab') as f:
# f.write('h哈哈哈哈哈hell
'.encode('utf-8'))
#
# 了解部分：
# print(f.readable()) # 是不是可读的
# print(f.writable())
文件操作
#！/usr/bin/env python
# Author:hongjie.gao
encoding='utf-8'
# 打开
f=open('a.txt',mode='r',encoding='utf-8')
# 读/写
# data=f.read()
# print(data)
# 关闭
# print(f)
# del f #回收python资源（自动回收）
# f.close() #回收操作系统的资源
# 流程分析：
# 1.向操作系统发起系统调用
# 2.操作系统打开这个文件，返回一个文件句柄给应用程序
# 3.在应用程序中把文件句柄赋值给一个变量
# 注意两点
# 1.打开一个文件对应两部分，一个是python级别的文件句柄，另外一个是操作系统打开的文件（默认打开文件的编码是以操作系统的
# 编码为准，除非open（）指定encoding='编码'）
# 2.当文件操作完毕后，应该回收两部分资源
# del f 回收应用程序资源（python解释器自动的垃圾回收机制已经替我们做了）
# f.close 回收操作系统资源
# 上下文管理
with open('a.txt',mode='r',encoding='utf-8') as f:
print(f.read())
补充---bool值
#！/usr/bin/env python
# Author:hongjie.gao
# bool值，所有的 数据类型都自带布尔值
# 布尔值为假的情况：0，空，None
# 数字类型，当x=0时为假
#
# x=1
# print(bool(x))
#
# if x:
# print('ok')
# 列表类型：当列表为空时为假（空字符串，空元组，空字典，空集合）
x=[]
print(bool(x))
为何要定义函数
#！/usr/bin/env python
# Author:hongjie.gao
# 组织结构混乱，可读性差
# 代码冗余
# 无法统一管理，维护难度极大
# 具备某一功能的工具即函数
# 函数的使用必须遵循：先定义，后调用
# 函数分类：
# 1：内置函数：python解释器自带的函数，python解释器启动就会定义好这些函数
# len()
# max()
# min()
# sum()
# 2：自定义函数
# 语法：
# def 函数名(参数1,参数2,...):
# """注释"""
# 函数体
# return 返回值
# 实现以下功能
'''
==========
==========
hello word
==========
==========
'''
# 定义阶段
def tell_tag():
print('==========')
def tell_msg(msg):
print(msg)
#调用阶段
tell_tag()
tell_tag()
tell_msg('hello word')
tell_tag()
tell_tag()
定义函数的三种模式
#！/usr/bin/env python
# Author:hongjie.gao
# # 定义无参函数
# def main():
# while True:
# user=input('>>:').strip()
# # if len(user)==0:continue
# if not user:continue
# password=input('>>:')
# res = auth(user,password)
# if res:
# print('login successful')
# else:
# print('login err')
# 定义有参函数：函数体的代码需要外部传入值
# def auth(user,pwd):
# if user == 'egen' and pwd == '123':
# return True
# else:
# return False
# main()
# def my_max(x,y):
# if x > y:
# return x
# else:
# return y
# res=my_max(1,3)
# print(res)
#
# 空函数
def foo(user,pwd):
pass
函数定义阶段干了什么
#！/usr/bin/env python
# Author:hongjie.gao
# 函数在定义阶段只检测语法，不执行代码
# def func():
# print('aaaaa')
# xxxxxx
# yyyyyyy
# zzzz
# dadada
# if
# print('dadadadad')
print(func) # 不报错（查看函数在内存地址的位置）
func() # 会报错
先定义后使用
#！/usr/bin/env python
# Author:hongjie.gao
# 1.函数的使用必须遵循先定义，后调用
# 2.函数的定义，就相当于在定义一个变量，如果没有定义而直接调用，就相当于在引用一个不存在的变量名
# 定义阶段
# def foo():
# print('from foo')
# bar() # 不报错
# # 调用阶段
# foo() # 包错
#
# 1.不报错
# 定义阶段
def bar():
print('from bar')
def foo():
print('from foo')
bar()
# 调用阶段
foo()
# 2.不报错
# 定义阶段
def bar():
print('from bar')
def foo():
print('from foo')
bar()
# 调用阶段
foo()
调用函数
#！/usr/bin/env python
# Author:hongjie.gao
# 1.调用函数 ：函数名（）
# 需要注意：先通过名字找到函数的内存地址，然后加（）调用
# 2.函数的返回值return
# 在调用函数的过程中，一旦执行到return，就会立刻终止函数，并且把return后的结果当做本次调用的返回值返回
# 函数体内可以有多个return但是只能执行一次
# def foo():
# print('1111')
# return 1
# # print('2222')
# # return 2
# # print('33333')
# # return 3
# res=foo()
# print('函数调用完毕：',res)
# 注意第二点
# 返回的值可以是任意类型
# def foo():
# return [1,2,3]
# res=foo()
# print('函数调用完毕：',type(res))
# 注意第三点：
#没有return,pyrhon会默认返回None
# def foo():
# pass
# res=foo()
# print('函数调用完毕：',res,type(res))
# 可以返回一个值======》值
# 可以用逗号分隔，返回多个值====》tuple
# def foo():
# return 1,2,[],{'a':1}
# res=foo()
# print('函数调用完毕：',res,type(res))
# 3.调用函数的三种形式
def foo():
print('from foo')
return 123
#
# foo()
#
# res=foo()
# print(res)
#
res=foo()*10
print(res)
函数的参数
#！/usr/bin/env python
# Author:hongjie.gao
# 形参：在定义函数时，括号内的参数称为形参
# 特点：形参就是变量名
# def foo(x,y):
# print(x)
# print(y)
# 实参：在调用函数时，括号内的参数称为实参
# 特点：实参就是变量值
# 在调用阶段实参（变量值）才会绑定到形参（变量名）
# 调用结束后解除绑定
# 参数的分类
# 位置参数：按照从左到右的顺序依次定义的参数
#位置形参：必须被传值，并且多一个不行，少一个不行
# # 位置实参：与形参按照位置一一对应
# def foo(x, y):
# print(x)
# print(y)
#
# foo('egon',1)
#
# 关键字实参 ：指的是按照name=value的形式，指名道姓的给name传值
# def foo(name, age):
# print(name)
# print(age)
#
# foo(age=18,name='egon')
# 关键字实参需要注意的问题是：
# def foo(name, age,sex):
# print(name)
# print(age)
# print(sex)
#
# foo('egon',18,'male')
# print('=======>')
# foo(age=18,name='egon',sex='male')
# print('======>')
# foo('egon',sex='male',age=18)
# w问题一：语法规定：位置实参必须在关键字实参前面
# 三：默认参数：在定义函数阶段，已经为形参赋值了，在定义阶段已经赋值，意味着在调用阶段可以不传值
# 注意的问题：
# 1.默认参数的值，只在定义时赋值一次
# 2.位置形参应该在默认参数的前面
# 3.默认参数的值应该是不可变类型
# def foo (x,y=10):
# print(x,y)
# foo(1)
# foo(x=1)
# foo(1,y=11)
# def register (name,age,sex='male'):
# print(name,age,sex)
#
# register('egon',18)
# register('wsb',20)
# register('alex',38,None)
'''
四：可变长参数：
实参的可变长度指的是：实参值得个数是不固定
而实参的定义形式无非两种：1.位置实参 2.关键字实参
针对这两种形式的实参个数不固定，相应的，形参也要有两种解决方案
*
**
'''
# 针对按照位置定义的溢出的那部分实参，形参用：*args
# def func(x,y,z,*args): #args=(4,5,6)
# print(x,y,z)
# print(args)
# func(1,2,3)
# func(1,2,3,4,5,6)
# func(1,2,3,*[4,5,6]) #func(1,2,3,4,5,6)
# func(*[1,2,3,4,5,6]) #func(1,2,3,4,5,6)
# def func(x,y,z):
# print(x,y,z)
#
# l=[1,2,3]
# func(*l)
# # 针对按照关键字定义的溢出的那部分实参，形参用：**kwargs
# def foo(x,y,**kwargs): # kwargs={'z': 11, 'a': 21, 'b': 90}
# print(x,y)
# print(kwargs)
# foo(y=2,x=1,z=11,a=21,b=90)
# def foo(a,b,*args,**kwargs):
# print(a,b)
# print(args)
# print(kwargs)
# # foo(1,2,3,x=22,y=33)
#
# foo(1,2,*[3],**{'x':22,'y':33}) #foo(1,2,3,x=22,y=33)
# def home(name,age,sex):
# print(name,age,sex)
#
#
# def wrapper(*args,**kwargs):
# print(args)
# print(kwargs)
#
# wrapper(1,2,3,4,a=1,b=2)
# 命名关键字参数（了解），
# 形参在*后定义的参数称之为命名关键字参数
# 它的特性是：传值时必须按照关键字实参的形式传值
def foo(a,b,*,x,y):
print(a,b,x,y)
foo(1,2,x=3,y=4)
# 位置参数，默认参数，*args，命名关键字参数,**kwargs
函数的对象
#函数是第一类对象：函数可以当做数据来使用
def foo():
print('from foo')
#可以被引用
# f=foo
# # print(f)
# f()
#可以当做参数传入一个函数
# def wrapper(x):
# # print(x)
# x()
# wrapper(foo)
#可以当做函数的返回值
# def wrapper():
# return foo
#
# f=wrapper()
# print(f is foo)
#可以当做容器类型的一个元素
# l=[foo,1,2]
# l[0]()
data_dir='/usr/local/mysql/data'
def select(sql):
print('select功能: ',sql)
def insert(sql):
print('insert功能: ', sql)
def update(sql):
print('update功能: ', sql)
def delete(sql):
print('delete功能: ', sql)
def alter(sql):
print('alter功能：',sql)
func_dic={
'select':select,
'update':update,
'insert':insert,
'delete':delete,
'alter':alter
}
def main():
while True:
inp=input('>>: ').strip()
if not inp:continue
sql=inp.split()
cmd=sql[0]
# if cmd == 'select':
# select(sql)
# elif cmd == 'update':
# update(sql)
# elif cmd == 'insert':
# insert(sql)
# elif cmd == 'delete':
# delete(sql)
if cmd in func_dic:
func_dic[cmd](sql)
else:
print('command not found')
main()
函数嵌套
#1 函数的嵌套调用:在调用一个函数的过程中，又调用其他的函数
# def my_max2(x,y):
# if x > y:
# return x
# else:
# return y
#
#
# def my_max4(a,b,c,d):
# res1=my_max2(a,b)
# res2=my_max2(res1,c)
# res3=my_max2(res2,d)
# return res3
#
# res=my_max4(1,2,3,4)
# print(res)
#2 函数的嵌套定义：在定义一个函数内部，又定义了一个函数
def f1():
def f2():
def f3():
print('from f3')
f3()
x=1
f2()
print(x)
f1()
# f2()
# print(x)
名称空间和作用域
名称空间：存放名字与值绑定关系的地方
内置名称空间：
存放的是：内置的名字与值的绑定关系
生效：python解释器启动
失效：Python解释器关闭
全局名称空间
存放的是：文件级别定义的名字与值的绑定
生效：执行python文件时，将该文件级别定义的名字与值的绑定关系存放起来
失效：文件执行完毕
局部名称空间
存放的是：函数内部定义的名字与值的绑定关系
生效：调用函数时，临时生效
失效：函数调用结束
加载顺序：先内置，再全局，最后局部
查找名字的顺序：先局部，再全局，最后内置
'''
# x=10
# if x > 3:
# y=2
#
# def foo(a,b): #a='aaaa' b='bbbb'
# m=11111
# n=2222
# def bar():pass
#
# foo('aaaa','bbbb')
# max=10
# def f1():
# max='f1'
# def f2():
# max='f2'
# print(max)
# f2()
#
# # f1()
# print(max)
'''
作用域：
全局作用域：包含内置名称空间的名字与全局名称空间的名字
全局存活，全局有效
局部作用域：包含局部名称空间的名字
临时存活，局部有效
'''
#
# x=1011111111111111111111111111111111111111111
# def f1(a):
# y='fffffffffffffffffffffffffffffff1'
# print(locals())
# print(globals())
# print(globals())
# print(dir(globals()['__builtins__']))
# print(locals() is globals())
# f1(12321312312312312312312312312312312312313213)
#作用域关系，在函数定义时，就已经固定了，与调用位置无关
# x=10000000000000000000000000
# def f1():
# def f2():
# # x='123123123123123123123123123123123'
# print(x)
# return f2
#
# f=f1()
#
# # print(f)
#
#
# def func():
# x=123
# f()
# x='hello'
# func()
#global nonlocal
# x=1
# def f1():
# global x
# x=10
# f1()
# print(x)
x=1
def f1():
x=2
def f2():
nonlocal x
x=111111
f2()
print(x)
f1()