Python基础学习笔记

from  time import *
import threading
import _thread
import queue
from  functools import  reduce
# coding：utf-8
# 列表的创建 修改 添加 删除 元素
# list = []
# list.append("hello")
# list.append("world")
# 动态在指定位置插入元素，但是当前插入位置超出最大位置时，不论写几，都是添加在最后
# list.insert(2, "good")
# del list[0]
# list[0]="Hello"
# print(list.pop())         # 注意，pop的返回值就是删除的元素
# print(list.pop(0))
# list.remove("hello")      # remove：当遇到多个值相同的时候，需要循环删除，因为每次只能删除一个值

# 排序
# list.append("aaa")
# list.sort()               # 注意，这是永久性排序
# sorted(list)              # 注意，这是临时排序

# 反转排列顺序
# list.reverse()

#  确定列表的长度
# len(list)
# 一般要索引最后一个元素时，
# print(list[-1])             # 表示倒数第一个

# 列表解析的方式创建列表
# i=10
# my_list=[i for i in range(10)]
# print(my_list)
# # a={}
# # print(a)
# my_dict={value:value1 for value,value1 in {1:1,2:2}.items() if value1 == 1}
# print(my_dict)

# 列表的 + * 运算
# a=[0]
# my_list=a*10                 # 表示重复，即将列表中的值重复n次添加到原有的列表中，这里注意列表嵌套的问题
# c = my_list + [1]            # 表示连接,注意，这里是新创建了一个列表并赋值给c
# my_list.extend([1,2,3,4])    # 注意，这两种方法是不一样的，extend是在原列表上添加

# 字典的注意问题，字典的键必须是不可变元素，所以列表啥的是不可以的，所以要用数字 字符串 元组作为键
# 字典的键不能重复，所以，当添加重复键的时候，去更新后的值
mydict = dict.fromkeys([1, 2, 3], 1)      # 这应该算是一个静态工厂方法
# 删除 清空 更新 添加
# del mydict[0]
# mydict.pop(1)           # 删除指定键的值，返回键对应的值，没有则返回default
# mydict.popitem()        # 随机删除一个键
# # del mydict
# # mydict.clear()
# mydict.update({4: 1})
# mydict.setdefault(5, 1)

# 获取时间
# print(asctime())

# lambda表达式
# lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数，这句话有问题，亲自尝试过后，lambda是可以访问全局变量的。
# a = b = 1
# def my_function():
#     return (lambda: list.count("world"))()
# print(my_function())


# 文件的处理
# f=open("a", "w" )
# f.write("12345")
# f.close()
# 自动关闭文件的方法
# with open("a", "r") as file_read:
#     print(file_read.read())

# file_read = open("a", "r")
# file_read.seek(2,0)
# var = file_read.read(2)
# print(var)
# file_read.close()

# 线程的实现
# def add_number(args1):
#     for i in range(10):
#         print(asctime()+" " + args1)
#
#
# _thread.start_new_thread(add_number, ("hello",))
# _thread.start_new_thread(add_number, ("world",))
#
# #!/usr/bin/python3


# 为线程定义一个函数
def print_time( threadName, delay):
    count = 0
    while count < 5:
        count += 1
        print(threadName, asctime())

# 创建两个线程,通过_thread.start_new_thread这种方式创建的线程打印的时候，没有将主线程设置为守护线程，所以主线程执行完之后就直接退出了，
#  所以控制台不会打印子线程的数据，通过threading.Thread(target=run),然后将子线程调用join方法
# _thread.start_new_thread( print_time, ("Thread-1", 2,) )
# _thread.start_new_thread( print_time, ("Thread-2", 4, ))
# thread_1 = threading.Thread(target=print_time,args=("thread_1",2,))
# thread_1.start()
# thread_1.join()

# 函数式编程：抽象程度很高的一种编程范式，真正的纯函数式编程没有变量，因为变量的状态是不确定的，所以一般函数式编程不应该有变量
# 其特点是允许函数作为参数传入另一个函数
# 既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
# def add(a,b):
#     return a+b
#
# def cadd(a,b,add):
#     print(add(a,b))
#
# cadd(1,2,add)
# def inverse(x):
#     return ~x
#
#
def cmplex(x):
    return x % 2 == 0
#
# def multi(x,y):
#     return x * 10 + y
#
# l = [1,2,3,4,5]

# map filter reduce 的用法
# print(list(map(inverse,l)))
# print(list(filter(cmplex,l)))
# print(reduce(multi,l))

#isinstance(object,Class) type(object == Class 的用法 判断当前对象是否是类或子类的一个实例

转载于:https://www.cnblogs.com/mhzhou-whyj/p/8848512.html