Python 基础知识 Day3

一　　集合的使用

集合是一个无序的，不重复的数据组合

1去重是集合的特点。把一个列表变成集合，就自动去重了。

2关系测试，测试两组数据之前的关系，例如交集、差集、并集关系。

__author__ = 'shellxie'
# -*- coding:utf-8 -*-
scg = [1,2,3,4,5,67,8,7,8]
scg= set(scg)
scg_1 = set([3,4,5,6,7,8,9,0])
print(scg,scg_1,type(scg))                        # 集合是无序的
print(scg.intersection(scg_1))                    # 取出交集
print(scg.union(scg_1))                           # 求并集
print(scg.difference(scg_1))                      # 求差集，我有你没有的就是差集，in scg not in scg_1
print(scg_1.difference(scg))
scg_2 =set([2])
print(scg_2.issubset(scg))                        # 判断scg_2是不是scg的子集，返回为真
print(scg.issuperset(scg_2))                      # 判断scg 是不是scg_2的父集，返回为真
print(scg.symmetric_difference(scg_1))            # 对称差集 ，把重复的去掉，然后合并
print(scg.isdisjoint(scg_1))                      # 如果两个集合没有任何交集则返回为真
print(scg & scg_1)                                # 交集
print(scg | scg_1)                                # 并集
print(scg - scg_1)                                # 差集
print(scg ^ scg_1)                                # 对称差集
scg.add("我的是你")                                # 添加一项
scg.update(["德玛西亚","无极之道"])                 # 添加多项
print(scg)
scg.remove("我的是你")                             # 删除一项
print(scg)
print(len(scg))                                   # 集合的长度
if "我的是你" not in scg:                          # 判断在不在
    print("yeah")
print(scg.pop())
print(scg.pop())                                  # 删除一个任意的元素
print(scg)
print(scg.discard("我的是你"))                     # 删除一个集合中的元素，如果集合里真的有这个元素则删除，如果集合里没有这个元素，只会返回None。而remove的时候集合里没有这个元素的话，程序会报错。

二　　文件操作

文件操作流程

1. 打开文件，得到文件句柄，并赋值给一个变量

2. 通过句柄对文件进行操作

3. 关闭文件

文件操作增删改查

__author__ = 'shellxie'
# -*- coding:utf-8 -*-
# f = open("fivemiles").read()
# print(f)
# f = open("fivemiles")                       # 文件句柄
# scg =f.read()
# scg1 = f.read()
# print(scg)
# print("-----------scg1-------------",scg1)  # 此时打印scg1 的时候 因为已经读过一遍了，内存指针停留在最后,所以再读的时候就是none输出
f =open("fivemiles","r")                      # r是读模式
f1 =open("fivemiles2","w")                    # w是写模式，创建一个文件，所以用的时候要慎重一点，会覆盖同名的文件
f1.write("我的剑就是你的剑\n")
f1.write("我的剑就是你的剑\n")
f2 = open("fivemiles2","a")                   # a是追加模式
f2.write("我的剑就是你的剑3")
#print(f2.read())                             # a追加模式同样也不能读
print(f.readline())                           # 读内存指针的所在那一行
print(f.readline())
print(f.readline())
print(f.readline())
print(f.readline())
for i in range(5):                            #用for 循环 来实现想读多少行就读多少行
    print(f.readline())

print(f.readlines())                          #把每行的东西作为一个元素放进一个列表,此时它是一个列表
print("---",f.readline())                     #此时内存指针又到了最后的地方，再打印时已经是none
f3 = open("fivemiles3","r")
for index,line in enumerate(f3.readlines()):
    if index ==9:
        print("--------索引下标位9是说明已经打印了九行了--------")
        continue
    print( line.strip() )                     # 比较耗费内存，需要把所有的读出来，是低级的循环

print("----------------------------------")
f4 =open("fivemiles4","r",encoding= "utf-8")
count =0
for line in f4:
    if count==9:
        print("我是分割线--------------------------------------")
        count +=1
    print(line)
    count +=1


print(f4.tell())                              # 此时光标在最后一个，所以打印的光标当前 的位置
f4.seek(0)                                    # 将光标移到初始的位置
print(f4.tell())
f4.seek(10)
print(f4.readline())                          # 从光标位置开始打印那一行
print(f4.encoding)                            # 打印编码
print(f4.fileno())                            # 内部维护的一个编号
print(f4.name)                                # 文件名
print(f4.seekable())                          # 不是所有的文件都能移动光标的，例如tty文件等等，能移动就返回True
print(f4.readable())                          # 判断文件是否可读
print(f4.flush())                             # 即时的刷新到硬盘中
import  sys,time
for i in range(30):
    sys.stdout.write("#")                     # 导入sys模块和time模块，stdout 是标准输出，标准输出写和即时刷新，0.1秒循环一次
    sys.stdout.flush()
    time.sleep(0.01)

print(f4.closed)                              # 判断文件是否关闭
f5 = open("fivemiles5","a",encoding="utf-8")
f5.seek(22)
f5.truncate()                                 # 这个是受seek的影响的，alex在视频里说错了！
f6 = open("fivemiles6","r+")                  # 以读和追加的模式打开，不管光标在那里都是在文件最后追加
f7 = open("fivemiles7","w+")                  # 写读的模式打开，不管光标在那里都是在文件最后追加
f8 = open("fivemiles8","a+")                  # 追加读写
f9 = open("fivemiles9","rb")                  # 二进制的格式读这个文件
f10 = open("fivemiles10","wb")                # 二进制的格式写
f10.write("hello \n".encode())
f11 = open("fivemiles11","ab")                # 二进制的格式追加
print(f6.readline())
print(f6.readline())
print(f6.readline())
print(f6.readline())
f6.write("---------------我是分割线")

修改文件

f=open("fivemiles","r")
f_new =open("fivemiles2.bak","w")
str_find ="那就是我"
replace_str = "那就是alex1"
for i in f:
    if str_find in i :
        i = i.replace(str_find,replace_str)    # 修改文件，源文件不动-创建一个新的
    f_new.write(i)
f.close()
f_new.close()

with 语句

with open("fivemiles","r") as f,\
        open("fivemiles2","r")as f1:             # python 官方建议的with 打开多个文件的格式，因为一行最好不要超过80个字符
    for line in f:
        print(line)

三　　字符编码与转码

中文的windows 默认是gb2312的编码

存一个英文字符或一个中文字符，unicode 所有的中文或者是英文都默认是占两个!

ASCII码里所有的英文字符都是占一个字节。ASCII码里是不能存中文的！！！

utf-8是一个可变长的字符编码，所有的英文字符依然是按照ASCII码的形式取存储，所有的中文字符统一是三个字节  

unicode 相当于一个大袋子，里面装着GBK、GB2312、还有其他的。

在python3里所有的字符默认都是unicode

在python2里默认的编码格式是ASCII

四　　Python函数介绍

1面向对象---华山派--->>>类--->>> class

2面向过程---少林派--->>>过程--->>> def

3函数式编程（最早的）---逍遥派--->>>函数--->>>def

编程语言中函数的定义：函数是逻辑结构化和过程化的一种编程方法。

python 中函数定义方法：

def  test(x):

　　"值“

　　x+=1

　　return x

def :定义函数的关键字

test:函数名

（）：内可定义形参

“” :文档描述，非必要的内容，但是强烈建议添加描述信息，好让自己不要遗忘和别人知道你这里函数表达的意思，例如pycharm源码就描述了这个函数的意思

x+=1 :泛指代码或程序处理逻辑

return：定义返回值

#函数

def func1():

　　"testing1"

　　print("in the func1")

　　return 0

#面向过程 ：就是没有返回值的函数

def func2():

　　"testing2"

　　print("in the func2")

 

x=func1()

y=func2()

print(x,y)

#输出结果为：

in the func1
in the func2
0 None

一开始不懂return 0的意思 然后网上找了一下，这个知乎er对   return 解释的很到位，给各位新手也借鉴一下！以下为原文{
（首先要了解，函数是什么？
书上可能会说函数是完成功能的模块之类的话。其实说白了，函数就是个你招来的工人。
你给他一些材料，告诉他怎么用这些材料拼装，然后他负责把拼装好的成品交给你。材料就是函数的参数，成品是函数的输出，而怎么拼装就是你写的函数体代码了。
比如这段代码
def worker(a, b, c):
    x = a + b
    y = x * c
这个工人（worker）在你的指导下，用a b c三个材料，装配出了x和y两个成品。
但是程序里的装配和工厂不同，用过的材料不会消失。这样，这个工人手里就有了a b c x y五样物品。他怎么知道你要的是哪个呢？
所以return的作用就是，在这种时候告诉工人你到底想要什么东西，是一个iPhone手机壳还是整台iPhone。例如
def worker(a, b, c):
    x = a + b
    y = x * c
    return y
这样工人就会把y交给你。当你让这个工人帮你干活（调用函数的时候）
result = worker(1, 2, 3)
你就会得到对应的结果（(1+2)*3）。

这就是return的作用。


作者：sqybi
来源：知乎}

def test():
    print("in the test")
def test1():
    print("in the test")
    return 0
def test2():
    print("in the test")
    return 1,"ss",[1,2],{3:1,4:2}

test()
test1()
test2()
x=test()
y=test1()
z=test2()
print(x)
print(y)
print(z)

　　

调用函数举例

__author__ = 'shellxie'
# -*- coding:utf-8 -*-
import time
def shopping():
    """this is shopping list"""
    time_format = "%Y-%m-%d %X"
    time_current = time.strftime(time_format)
    with open("a.txt","a+") as f:
        f.write("%s end action"% time_current)
    product_list =[
        ("森海塞尔耳机",3880),
        ("高配大屏台式机",16880),
        ("捷安特自行车",3880),
        ("大床",6680),
        ("拿铁",38),
        ("苹果7p",5880)
    ]
    salary = input("input your salary:")
    shopping_list=[]
    if salary.isdigit():
        salary =int(salary)
        while True:
            for index,item in enumerate(product_list):
                print(index,item)
            choice= input("input the code that you wanna buy:")
            if choice.isdigit():
                choice=int(choice)
                if choice<len(product_list) and choice>=0:
                    p_item =product_list[choice]
                    if p_item[1]<= salary:
                        shopping_list.append(p_item)
                        salary -=p_item[1]
                        print("add %s into you shopping list,and your 余额 is \033[40;1m %s \033[0m"%(p_item,salary))
                    else:
                        print("your 余额 is \033[40;1m not enough \033[0m to buy,please 跟我学python吧")
                else:
                    print("correct number please")
            elif choice == "q":
                print("------SHOPPING CART------")
                for p in shopping_list:
                    print(p)
                print("你的余额还剩 \033[41;1m %s \033[0m"%salary)
                exit()

            else:
                print("Only \033[40;1m Number \033[0m Please")        #42代表背景绿 41代表背景红 40 代表背景黑色
    else:
          print("\033[42;1m ONLY NUMBERS PLEASE\033[0m")


def test():
    print("购物车")
    shopping()

test()

函数参数

def test(x,y):                             # x和y是形参
    print(x)
    print(y)
test(1,2)                                  # 1和2 是实参
test(x=1,y=2)                              # 关键字参数调用，与形参顺序无关
test(1,2)                                  # 位置参数调用，与形参一一对应
test(2,y=3)                                # 关键参数不能写在位置参数前面

默认参数

def test(x,y=2):                             # 默认参数的特点：调用函数的时候，默认参数非必需传递的。也就是说形参如果有值了，在实参里面你不写，是可以的，函数调用的时候就直接用默认的形参！
    print(x)                                 # 用途是 1.默认安装值 2.
    print(y)

test(1)
test(1,3)                                    # 但是如果实参写了，调用函数的是会以实参为准

*agrs 和 **args 的应用

#args 只能接收n个位置参数，然后转化成元组的形式
def test(*args):
    print(args)

test(1,2,3,4,56,7,6)
test(*[1,2,3,4,5,6,7])
test(*[1,2,3,4,5,6])                           # args = tuple ([1,2,3,4,5])

print("------------")

def test1(x,*args):                            # *args 会把多传入的参数变成一个元组形式
    print(x)
    print(*args)
    test1(1,2,3,4,5,6,7)

# **kwargs 只能把n个关键字参数，转换成字典的方式,一定要是关键字参数
def test(**kwargs):                              # **代表接收字典
    print(kwargs)
    print(kwargs["name"])
    print(kwargs["age"])
test(name="alex",age=22,sex= "f")                # 把关键字参数按照字典的方式存放起来
test(**{"name":"alex","age":8})

def test (name,age,*args,**kwargs):                # 输出结果
    print(name,age,args,kwargs)                    # Alex 22 () {}
test("alex",32)                                    # 后面这个{}就是kwargs,只是因为没传值,所以为空
test("alex",32,"cn","python",sex="male",province= "anhui")

作用域、局部与全局变量

 school = "SCG"                              # 全局变量 ,能用在这里的任何地方
def change_name(name):
    global school                           # 在函数里把局部变量修改成全局变量
    school = "ShiDao"
    print("before chagne ",name,school)
    name = "SHELL"                          # 这里的name  就是局部变量，而这个函数就是这个变量的作用域
    print("after chagne",name)

print(school)                               # 这里的打印scholl 是函数没调用之前
name = "alex"
change_name(name)
print(name)
print(school)                               # 这里打印的school 是把函数里的局部变量改成了全局变量之后

递归

在函数内部可以调用其他函数。如果调用自己本身，这个函数就是递归函数。

1 递归必须有一个明确的结束条件

2 每次进入更深一层的递归是，问题的规模比上次递归的都应该有所减少

3 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

def alex(n):
    print(n)
    if int(n/2) >0 :
        return alex(int(n/2))              # int的功能是把他转化成整数
    print(">>>>>",n)


alex(10)

函数式编程介绍

数学里面的函数，输入是确定的，输出是一定确定的。但是在我们python函数里面。输入是确定的，而输出是不一定确定的

例如

#f(x,y) , z= 3x+2y              #这个是数学里面的二元函数，如果输入是固定的，输出也就是固定的
def scg(x,y) :                   # 因为存在逻辑运算，所以输出不是固定的
    if x +y > 9:
        return  0

scg(2,6)
print(scg(2,6))

函数是编程语言去学 lisp,hashshell,erlang

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就可以称为高阶函数。

def add(a,b,f):                         # 高阶函数，abs 是一个求绝对值的内部自定义函数
    return f(a) + f(b)

print( add(3,-6,abs)
)

　　

 

转载于:https://www.cnblogs.com/shellxieN/p/6859111.html