python基础

最新推荐文章于 2021-03-25 23:13:42 发布
最新推荐文章于 2021-03-25 23:13:42 发布
阅读量401 收藏 2
点赞数 1
分类专栏： python

python基础

这篇算是教程吧，该教程适合已经有过其他语言基础的学者，该教程只是为了达到熟悉 python 的语法

数据类型

  • string
print("hello world")
print('hello world')
print('''hello world''')
print(name +"name" + str(age) +"age")
print("{0}".format(name))
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

hello world
hello world
hello world
helloname13age
hello

python字符串前面加u,r,b的含义
u/U:表示unicode字符串
r/R:非转义的原始字符串 
b:bytes
  • complex
a = 3
b = 4
e = complex(a,b)
f = e
print(e)
print(e+f)
print(4.0/3.0)
print(4.0//3.0)
print(sys.float_info)
print(b, end=',')
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

(3+4j)
(6+8j)
1.3333333333333333
1.0
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
  • List
number_list=[1,2,3,4,5,6]
number_list[-1]=5
del number_list[1]
number_list.append(5)
3 in number_list
number_list[1:3]

1   len(list)
列表元素个数
2   max(list)
返回列表元素最大值
3   min(list)
返回列表元素最小值
4   list(seq)
将元组转换为列表
  • tuple
a_tuple =(2,1,[1,5,6,9])
b_tuple =(3,)

tuple(seq)
将列表转换为元组。
  • 字典
key->value
d = {key1 : value1, key2 : value2 }
dict['Name']=8
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():

type(variable)
key in dict
popitem()
随机返回并删除字典中的一对键和值(一般删除末尾对)。
  • set
set和dict类似  ,但set 无重复key 但也无对应的value
set需要一个list来创建
a = set([1,2,3,3,4,5])
print(a) #{1, 2, 3, 4, 5}
a.add(6)
a.remove(5)# 5是对应的key 不是index=5 
print(a)
  • 切片
a = [1,2,5,6,4,2,5,5]
b = a[0:-2]
print(b)# [1, 2, 5, 6, 4, 2]
b = a[-2:0]
print(b)# []
b = a[:2]
print(b)# [1, 2]
b = a[0:5:2]
print(b)# [1, 5, 4]
b = a[1:10:2]
print(b)# [2, 6, 2, 5]
b = a[::2]
print(b) # [1, 5, 4, 5]
  • 条件控制
if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3
  • 循环
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

for i in range(5):
pass 是空语句
  • 迭代器与生成器
迭代器
list=[1,2,3,4]
it = iter(list) 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

生成器
a = [x*x for x in range(100)]
b = (x*x for x in range(100))
 a和b的区别在于a是list b是generator

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
什么情况下需要使用 yield？
一个函数 f，f 返回一个 list，这个 list 是动态计算出来的

next 函数之类的，实际上的运行方式是每次的调用都在 yield 处中断并返回一个结果，然后再次调用的时候再恢复中断继续运行。

操作运算

  • 三目运算
b = 50 if True else 35

函数

def 函数名（参数列表）:
    函数体

必需参数 def printme( str ):

关键字参数printme( str = "菜鸟教程");

默认参数 def printinfo( name, age = 35 ):

不定长参数
vartuple    ->tuple
var         ->字典
def printinfo( arg1, *vartuple **var):
printinfo( 70, 60, 50 );
  • 匿名函数
python 使用 lambda 来创建匿名函数。
lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda ｘ, ｙ: ｘ+ ｙ;
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
  • 变量作用域
L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内建作用域

x = int(2.9)  # 内建作用域

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

global 和 nonlocal关键字
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
1
123


def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()
100
100
  • 高级函数map() reduce()
# map()

#　map(func, iter1)
def func(x):
    return x*x
a = [1,2,5,3,6,9,10]
for x in map(func,a):#　也可以使用lambda 表达式
    print(x,end=" ")　#1 4 25 9 36 81 100 


# reduce()

f = lambda a,b:a*10+b
a = [1,2,5,6,9,10]

print(reduce(f,a)) #125698
  • 返回函数


def cacl_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax += n
    return sum

f = cacl_sum(1,2,5,34,2,5,6,10,5,8)
f()
  • filter（）
# 用于过滤序列  和map类似
def is_odd(n):
    return n%2==1

a = [1,2,5,34,2,5,6,10,5,8]

for i in filter(is_odd,a):
    print(i,end=" ")#1 5 5 5 

def is_odd(n):
    return n%2==1

a = [1,2,5,34,2,5,6,10,5,8]

for i in map(is_odd,a):
    print(i,end=" ")#　True False True False False True False False True False
  • 装饰器
def decorator(func):
    def inner():
        return func() + " hello"
    return inner

@decorator
def fun():
    return "now"

print(fun()) #now hello
print(fun.__name__) # inner
  • 偏函数

import  functools
int2 = functools.partial(int,base=2)
a = int2('100000')
print(a) # 32

数据结构

  • 栈
将列表当做堆栈使用

stack = [3, 4, 5]
stack.append(6)
stack.pop()
  • 作队
from collections import deque

queue = deque(["Eric", "John", "Michael"])
queue.append("Terry") 
queue.popleft()
  • 列表推导式
vec = [2, 4, 6]
[3*x for x in vec]  //[6, 12, 18]

包 模块 package

  • import 导入
import os
from…import 
from modname import *
print(os.getcwd())
  • 属性
__name__
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。
  • dir() 函数
dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
  • 包
sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

输入和输出

  • 输入输出
str = raw_input("请输入：");
# input([prompt]) 函数和raw_input([prompt]) 函数基本可以互换，但是input会假设你的输入是一个有效的Python表达式，并返回运算结果。
str = input("Enter your input: ");
  • 读和写文件
open(filename, mode)

模式  描述
r   只读。文件指针放在文件头。默认模式。
rb  二进制格式打开一个文件只读。默认模式。
r+  打开一个文件用于读写。
rb+ 以二进制格式打开一个文件用于读写。
w   打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb  以二进制格式打开一个文件只用于写入。
w+  打开一个文件用于读写。
wb+ 以二进制格式打开一个文件用于读写。
a   打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab  以二进制格式打开一个文件用于追加。
a+  打开一个文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。

不同模式打开文件的完全列表

f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()
  • 相关函数
1   file.close()
关闭文件。关闭后文件不能再进行读写操作。
2   file.flush()
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3   file.fileno()
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4   file.isatty()
如果文件连接到一个终端设备返回 True，否则返回 False。
5   file.next()
返回文件下一行。
6   file.read([size])
从文件读取指定的字节数，如果未给定或为负则读取所有。
7   file.readline([size])
读取整行，包括 "\n" 字符。
8   file.readlines([sizeint])
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9   file.seek(offset[, whence])
设置文件当前位置
10  file.tell()
返回文件当前位置。
11  file.truncate([size])
从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后 V 后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。
12  file.write(str)
将字符串写入文件，没有返回值。
13  file.writelines(sequence)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

OS 文件/目录方法

  • os.acccess(path,mode)
import os,sys

os.F_OK  #测试path是否存在。
os.R_OK  #测试path是否可读。
os.W_OK  #测试path是否可写。
os.X_OK  #测试path是否可执行。
ret = os.access(os.getcwd(),os.X_OK)
print(ret)
  • os.chdir(path) 当前工作目录到指定的路径
  • os.chflags() 方法用于设置路径的标记为数字标记。多个标记可以使用 OR 来组合起来。只支持在 Unix 下使用。
  • os.chmod(path, mode) 更改文件或目录的权限。
  • os.close(fd) 关闭文件描述符 fd
  • os.getcwd() 返回当前工作目录
  • os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
  • os.makedirs(path[, mode]) 递归文件夹创建函数。
  • os.open(file, flags[, mode])
  • os.pathconf(path, name)
  • os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
  • os.write(fd, str)
  • os.rmdir(‘dirname’) 删除目录
  • os.system(‘command’) 可以执行系统命令

异常

  • 异常处理
while True:
        try:
            x = int(input("Please enter a number: "))
            break
        except ValueError:
            print("Oops!  That was no valid number.  Try again   ")


#最后一个except子句可以忽略异常的名称，它将被当作通配符使用
try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise #Python 使用 raise 语句抛出一个指定的异常。例如:


#try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。
try:
    a=3
except :
    print('cannot open')
else:
    print("ok")

try:
     raise KeyboardInterrupt
finally:
     print('Goodbye, world!')
finally 和else 同时存在时 finally要放于最后
  • 用户自定义异常
class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)
  • 预定义的清理行为
#关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:
with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

Python 高级编程

面向对象

  • 类(Class)
class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体
# 类的帮助信息可以通过ClassName.__doc__查看。
  • 构造方法
def __init__(self):
    self.data = []
  • 类的方法 数据成员
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

  • python中没有函数重载

    原因两点： 
    python的函数可以接收任意类型参数 
    python的函数可以定义可变参数个数 
    所以不需要函数重载

  • 继承

class Person:
    __name = ''
    __age = 0

    def __init__(self, name = 'Person', age=18):
        self.__name = name
        self.__age = age

    def say(self):
        print("Person name is {0},I am {1}".format(self.__name, self.__age))



class Parent:
    __name= ''
    __age = 0
    def __init__(self,name = 'Parent',age=0):
        self.__name=name
        self.__age=age

    def say(self):
        print("Parent name is {0},I am {1}".format(self.__name,self.__age))


class Son(Parent,Person):
    __gender =''
    def __init__(self,gender='F'):
        Parent.__init__(self)
        Person.__init__(self)
        self.__gender = gender
    def say(self):
        Parent.say(self)
        Person.say(self)
        print("Son gender is " + self.__gender)
  • @property 
    在方法前面加上@property 可将方法当只读属性使用
class Student():


    def __init__(self):
        self.__name='Student'

        pass
    #使用@property添加一个name属性
    @property
    def name(self):
        return self.__name


s1 = Student()
print(s1.name)
  • 类的专有方法：
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用 s = student()  s()
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 乘方
  • 类的专有属性：
__name__: 类名
__slots__:规定类中的属性  但就不能使用@property
__module__:模式
__doc__:说明文档字符串
__dict__:字典
  • 描述符
__get__
__set__
__delete__


class Student():

    def __init__(self):
        self.name='name'

    def __get__(self, instance, owner):
        return self.name
    def __set__(self, instance, value):
        self.name=value

    def __delete__(self, instance):
        pass


class t:
    a = Student()
    b = Student()
T = t()
print(t.a)
t.b='hello'
print(t.b)
# name
# hello
  • 反射 提供字符串操作类的属性、方法 
    主要函数工具 

hasattr(obj_name.’name’) 
setattr(obj_name,’name’,value) 
getattr(obj_name,’name’)

class Student():

    def __init__(self):
        self.name='name'

a = Student()
print(hasattr(a,'name'))
  • 静态方法 
    @staticmethod 装饰 
    参数不用self
  • 类方法 
    @classmethode 必须提供cls参数

标准库概览

  • os 操作系统接口
import os
os.getcwd()      # 返回当前的工作目录
#'C:\\Python36'

import shutil
shutil.copyfile('./test.py', './test_cope.py')
shutil.move('./test_cope.py', '../test_cope.py')
  • glob 文件通配符
import glob
print(glob.glob('*.py'))
  • 数学
import math
math.cos(math.pi / 4)

import random
random.choice(['apple', 'pear', 'banana'])
random.sample(range(100), 10)
random.random()
random.randrange(6)
  • 正则表达式
import re
re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

re.match(pattern, string, flags=0
#匹配成功re.match方法返回一个匹配的对象，否则返回None。
#我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

re.search(pattern, string, flags=0)
#re.search 会在字符串内查找模式匹配，直到找到第一个匹配。


#re.match与re.search的区别
# re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。


re.I    使匹配对大小写不敏感
re.L    做本地化识别（locale-aware）匹配
re.M    多行匹配，影响 ^ 和 $
re.S    使 . 匹配包括换行在内的所有字符
re.U    根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X    该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
  • 日期和时间
from datetime import date
now = date.today()
now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'

now = date.today()
birthday = date(1964, 7, 31)
age = now - birthday
age.days
  • 数据压缩
import zlib

s = b'witch which has which witches wrist watch'
a = len(s)
print(a)
print(s)
t = zlib.compress(s)
b = len(t)
print(b)
print(t)

zlib.decompress(t)

zlib.crc32(s)
  • 访问 互联网
for line in urlopen('https://www.cnblogs.com/littleseven/p/5599019.html'):
        line = line.decode('utf-8')  
        if 'Ctrl' in line or 'EDT' in line:  
            print(line)

#sendEmail
import smtplib
server = smtplib.SMTP()
server.sendmail()
server.quit()
from timeit import Timer
a = Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
print(a)

b = Timer('a,b = b,a', 'a=1; b=2').timeit()
print(b)

CGI

CGI(Common Gateway Interface),通用网关接口,它是一段程序,运行在服务器上如：HTTP服务器，提供同客户端HTML页面的接口。 
CGI架构图

  • 第一个CGI程序
#coding=utf-8
#!c:\python27\python.exe

print "Content-type:text/html\r\n\r\n"
print '<html>'
print '<head>'
print '<title>Hello Word - First CGI Program</title>'
print '</head>'
print '<body>'
print '<h2>Hello Word! This is my first CGI program</h2>'
print '</body>'
print '</html>'

操作mysql数据库

MySQLdb
import MySQLdb
db = MySQLdb.connect("host","user","passwd","TESTDB" )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# 使用execute方法执行SQL语句
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取一条数据库。
data = cursor.fetchone()
# 提交到数据库执行
db.commit()

# 发生错误时回滚
db.rollback()
  • 数据库查询操作
Python查询Mysql使用 fetchone() 方法获取单条数据, 使用fetchall() 方法获取多条数据。
try:
   # 执行SQL语句
   cursor.execute(sql)
   # 获取所有记录列表
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
      # 打印结果
      print "fname=%s,lname=%s,age=%d,sex=%s,income=%d" % \
             (fname, lname, age, sex, income )
except:
   print "Error: unable to fecth data"

# 关闭数据库连接
db.close()
pymysql

操作和MySqldb大同小异 
但在python3中pymysql将取代MySqldb

网络编程

Python 提供了两个级别访问的网络服务
  • 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。

  • 高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

  • socket()函数

socket.socket([family[, type[, proto]]])
# family: 套接字家族可以使AF_UNIX或者AF_INET
# type: 套接字类型可以根据是面向连接的还是非连接分为#SOCK_STREAM或SOCK_DGRAM
# protocol: 一般不填默认为0.
  • Socket 对象方法
s.bind()    绑定地址（host,port）
s.listen()  开始TCP监听。
s.accept()  被动接受TCP客户端连接
s.connect() 初始化TCP服务器连接，
s.connect_ex()  connect()函数的扩展版本
s.recv()    接收TCP数据，
s.send()    发送TCP数据，
s.sendall() 完整发送TCP数据，
s.recvfrom()    接收UDP数据，
s.sendto()  发送UDP数据，
s.close()   关闭套接字
s.getpeername() 返回连接套接字的远程地址
s.getsockname() 返回套接字自己的地址。
s.setsockopt(level,optname,value)   设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])    返回套接字选项的值。
s.settimeout(timeout)   设置套接字操作的超时期，timeout是一个浮点数，单位是秒。
s.gettimeout()  返回当前超时期的值
s.fileno()  返回套接字的文件描述符。
s.setblocking(flag) 如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。
s.makefile()    创建一个与该套接字相关连的文件
my_sender='my_sender@qq.com' # 发件人邮箱账号
my_pass = 'my_pass '    # 发件人邮箱密码(当时申请smtp给的口令)
my_user='my_user@qq.com'  # 收件人邮箱账号，我这边发送给自己r


def mail():
 ret=True
 try:
  msg=MIMEText('<邮件内容>','plain','utf-8')
  msg['From']=formataddr(["xxxxxx",my_sender])
  # 括号里的对应发件人邮箱昵称、发件人邮箱账号
  msg['To']=formataddr(["xxxxxxx",my_user])
  # 括号里的对应收件人邮箱昵称、收件人邮箱账号
  msg['Subject']= '邮件主题'
  # 邮件的主题，也可以说是标题

  server=smtplib.SMTP_SSL("smtp.qq.com", 465)
  # 发件人邮箱中的SMTP服务器，端口是465
  server.login(my_sender, my_pass)
  # 括号中对应的是发件人邮箱账号、邮箱密码
  server.sendmail(my_sender,[my_user,],msg.as_string())
   # 括号中对应的是发件人邮箱账号、收件人邮箱账号、发送邮件
  server.quit()# 关闭连接
 except Exception:# 如果 try 中的语句没有执行，则会执行下面的 ret=False
  ret=False
 return ret

多线程

  • 两种方式：函数或者用类来包装线程对象。
  • 函数式：调用thread模块中的start_new_thread()函数来产生新线程。
_thread.start_new_thread ( function, args[, kwargs] )
#function - 线程函数。
#args - 传递给线程函数的参数,他必须是个tuple类型。
#kwargs - 可选参数。
import _thread


def hello(name,age):
    while 1:
        print(name+str(age))
        age += 1


# 创建两个线程
try:
   _thread.start_new_thread( hello, ('thread=======>111  ',1 ) )
   _thread.start_new_thread( hello, ('thread==>222  ',1 ) )
except:
   print ("Error: 无法启动线程")

while 1:
   pass
  • 使用 threading 模块创建线程

threading.currentThread(): 返回当前的线程变量。 
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。 
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法: 
run(): 用以表示线程活动的方法。 
start():启动线程活动。 
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。 
isAlive(): 返回线程是否活动的。 
getName(): 返回线程名。 
setName(): 设置线程名。

class myThread (threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)

        self.name = name

    def run(self):
        l=0
        while 1:
            print(self.name)



# 创建新线程
thread1 = myThread("Thread-------->>>1   ")
thread2 = myThread("Thread--->2  ")

# 开启新线程
thread1.start()
thread2.start()
  • 线程同步

import threading
import time


threadLock = threading.Lock()
class myThread (threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)

        self.name = name

    def run(self):
        l=0

        while 1:
            time.sleep(2)
            print("开启线程： " + self.name)
            # 获取锁，用于线程同步
            threadLock.acquire()
            # 释放锁，开启下一个线程
            threadLock.release()
            print("关闭线程：   ")
# 创建新线程
thread1 = myThread("Thread-------->>>1   ")
thread2 = myThread("Thread--->2  ")

# 开启新线程
thread1.start()
thread2.start()

print ("退出主线程")
  • 线程优先级队列
queue.qsize() 返回队列的大小
queue.empty() 如果队列为空，返回True,反之False
queue.full() 如果队列满了，返回True,反之False
queue.full 与 maxsize 大小对应
queue.get([block[, timeout]])获取队列，timeout等待时间
queue.get_nowait() 相当queue.get(False)
queue.put(item) 写入队列，timeout等待时间
queue.put_nowait(item) 相当queue.put(item, False)
queue.task_done() 在完成一项工作之后，queue.task_done()函数向任务已经完成的队列发送一个信号
queue.join() 实际上意味着等到队列为空，再执行别的操作

XML解析

python有三种方法解析XML，SAX，DOM，以及ElementTree:
<collection shelf="New Arrivals">
<movie title="Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title="Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>
# 1、对大型文件进行处理；
# 2、只需要文件的部分内容，或者只需从文件中得到特定信息。
# 3、想建立自己的对象模型的时候。
# 在python中使用sax方式处理xml要先引入xml.sax中的parse函数，还有xml.sax.handler中的ContentHandler。
# xml.sax.make_parser( [parser_list] )
    #parser_list - 可选参数，解析器列表
# xml.sax.parse( xmlfile, contenthandler[, errorhandler])
    #xmlfile - xml文件名
    #contenthandler - 必须是一个ContentHandler的对象
    #errorhandler - 如果指定该参数，errorhandler必须是一个SAX ErrorHandler对象
# xml.sax.parseString(xmlstring, contenthandler[, errorhandler])
    #xmlstring - xml字符串
    #contenthandler - 必须是一个ContentHandler的对象
    #errorhandler - 如果指定该参数，errorhandler必须是一个SAX ErrorHandler对象
  • SAX模块解析xml

import xml.sax
import xml.sax.handler


class MyHandler(xml.sax.ContentHandler):
    def __init__(self):
        xml.sax.ContentHandler.__init__(self)
        self.CurrentData=""
        self.type=""
        self.forma=""
        self.year=""
        self.rating=""
        self.stars=""
        self.description =""
    def startElement(self,tag,attributes):
        self.CurrentData=tag
        if tag=="movie":
            print("***movie***")
            title =attributes['title']
            print("Title: ", title)
        # 元素开始调用

    def startElement(self, tag, attributes):
        self.CurrentData = tag
        if tag == "movie":
            print("*****Movie*****")
            title = attributes["title"]
            print("Title:", title)

        # 元素结束调用

    def endElement(self, tag):
        if self.CurrentData == "type":
            print("Type:", self.type)
        elif self.CurrentData == "format":
            print("Format:", self.format)
        elif self.CurrentData == "year":
            print("Year:", self.year)
        elif self.CurrentData == "rating":
            print("Rating:", self.rating)
        elif self.CurrentData == "stars":
            print("Stars:", self.stars)
        elif self.CurrentData == "description":
            print("Description:", self.description)
        self.CurrentData = ""

        # 读取字符时调用

    def characters(self, content):
        if self.CurrentData == "type":
            self.type = content
        elif self.CurrentData == "format":
            self.format = content
        elif self.CurrentData == "year":
            self.year = content
        elif self.CurrentData == "rating":
            self.rating = content
        elif self.CurrentData == "stars":
            self.stars = content
        elif self.CurrentData == "description":
            self.description = content


if __name__=="__main__":

    parser = xml.sax.make_parser()

    parser.setFeature(xml.sax.handler.feature_namespaces,0)

    Handle = MyHandler()
    parser.setContentHandler(Handle)
    parser.parse("xmltest.xml")
  • dom模块解析xml
常用方法
minidom.parse(filename)    #加载读取XML文件

doc.documentElement        #获取XML文档对象

node.getAttribute(AttributeName)    #获取XML节点属性值

node.getElementsByTagName(TagName)    #获取XML节点对象集合

node.childNodes    #返回子节点列表。

node.childNodes[index].nodeValue    #获取XML节点值

node.firstChild    #访问第一个节点。等价于pagexml.childNodes[0]

doc = minidom.parse(filename)
doc.toxml('UTF-8')    #返回Node节点的xml表示的文本

Node.attributes["id"]    #访问元素属性
a.name    #就是上面的 "id"
a.value    #属性的值

from xml.dom.minidom import parse
import xml.dom.minidom



DOMTree = xml.dom.minidom.parse('xmltest.xml')

collection = DOMTree.documentElement

if collection.hasAttribute('shelf'):
    print("Root Elemt: %s" % collection.getAttribute('shelf'))
movies = collection.getElementsByTagName('movie')

for movie in movies:
    print('****movie****')
    if movie.hasAttribute('title'):
        print('titile:  %s ' % movie.getAttribute('title'))

    type = movie.getElementsByTagName('type')[0]
    print("type:  %s " % type.childNodes[0].data)

    format = movie.getElementsByTagName('format')[0]
    print("format:  %s " % format.childNodes[0].data)

    year = movie.getElementsByTagName('year')[0]
    print("year:  %s " % year.childNodes[0].data)

    rating = movie.getElementsByTagName('rating')[0]
    print("rating:  %s " % rating.childNodes[0].data)

    stars = movie.getElementsByTagName('stars')[0]
    print("stars:  %s " % stars.childNodes[0].data)

    description = movie.getElementsByTagName('description')[0]
    print("description:  %s " % description.childNodes[0].data)
  • ElementTree解析xml
常用方法
Element.findAll()：查找当前element的孩子的属于某个tag的element；

Element.find()：查找属于某个tag的第一个element；

Element.text：访问Element的文本内容；

Element.get()：访问Element的属性；　（当属性>1的时候很有用）

Element.iter()：迭代遍历子节点。
import xml.etree.cElementTree as et

tree = et.parse('xmltest.xml')

root =tree.getroot()

for movie in root:
    print ('*'*30)
    print ("title:", movie.attrib['title'])
    print ("type:", movie[0].text)
    print ("format:", movie[0].text)
    print ("year:", movie[0].text)
    print ("rating:", movie[0].text)
    print ("stars:", movie[0].text)
    print ("description:", movie[0].text)

JSON解析

Python3 中可以使用 json 模块来对 JSON 数据进行编解码，它包含了两个函数：

  • json.dumps(): 对数据进行编码。
  • json.loads(): 对数据进行解码。
import  json


data = {
    'no':1,
    'name':'king',
    'url': 'https://www.jianshu.com/u/f4a34d77c5c4'
}

json_str = json.dumps(data)

data = json.loads(json_str)

print(data['no'])
print(data['name'])
print(data['url'])

GUI 图形开发界面

python2.x

python2.x 几个常用Python GUI库如下

  • Tkinter ( python3中名为tkinter) 
    Tkinter模块(“Tk 接口”)是Python的标准Tk GUI工具包的接口.Tk和Tkinter可以在大多数的Unix平台下使用,同样可以应用在Windows和Macintosh系统里.,Tk8.0的后续版本可以实现本地窗口风格,并良好地运行在绝大多数平台中。
  • wxPython 
    wxPython 是一款开源软件，是 Python 语言的一套优秀的 GUI 图形库，允许 Python 程序员很方便的创建完整的、功能键全的 GUI 用户界面。
  • Jython 
    Jython程序可以和Java无缝集成。除了一些标准模块，Jython使用Java的模块。Jython几乎拥有标准的Python中不依赖于C语言的全部模块。比如，Jython的用户界面将使用Swing，AWT或者SWT。Jython可以被动态或静态地编译成Java字节码。
Tkinter
  • Tkinter 是Python的标准GUI库。Python使用Tkinter可以快速的创建GUI应用程序。
import Tkinter
top = Tkinter.Tk()
# 进入消息循环
top.mainloop()
python3.x
tkinter
import tkinter
top = tkinter.Tk()
# 进入消息循环
top.mainloop()
pyqt
from PyQt5 import QtWidgets, QtGui
import sys

app = QtWidgets.QApplication(sys.argv)
window = QtWidgets.QWidget();
window.show()
sys.exit(app.exec_())
MOJY_1825
关注
专栏目录
《Python基础教程》专栏总结篇
weixin_43178406的博客
10-11 17万+
今天给大家带来的文章是《Python基础教程》专栏总结篇，希望能对同学们有所帮助。 文章目录 1. 背景 2. 专栏亮点 3. 你的收获 4. 详细目录
(1) Python基础
qq_40230458的博客
12-12 232
1、变量：     在python中不需要明确指定变量的类型，会根据后面赋值指定好创建的变量类型     不需要使用分号，直接写下一行代码     在创建变量时的通用做法是下划线如：day_1 day_2     打印反馈 print() 3.0版本必须写()          打印变量类型 print(type())          类型转换 str_eight=str(8)     ...
python中row[0_python效率和内存中的大对象
weixin_39573136的博客
01-14 422
由于收集的速度与行增长速度相同,因此内存使用率将保持稳定. gc.collect()调用不会产生太大的影响.CPython中的内存管理很微妙.仅仅因为删除引用并运行收集周期并不一定意味着内存将返回到OS.见this answer for details.要真正节省内存,您应该围绕生成器和迭代器而不是大型项列表来构造此代码.我很惊讶你说你有连接超时,因为获取所有行不应该花费比一次取一行并执行你正在进...
【Python自学笔记】读写csv文件
zgscwxd的博客
10-28 494
https://blog.csdn.net/atnanyang/article/details/70832257 本文主要使用csv和pandas两个模块，首先肯定得导入两个模块 import csv import pandas as pd csv文件的内容如下，假设为GT.csv Test_001 Tumor IDC1 Macro Test_002 Tumo...
python中row[0_python-获取数据帧中每行的最右边非零值位...
weixin_34684705的博客
12-23 1511
我有一个很大的数据框,并且如果右边有零,则需要获取其中每一行的最后一个零值索引.如果行中没有零,则需要最后一个索引.下面的工作代码.输出正确.有没有办法向量化此代码(不使用lambda)示例代码：df = pd.DataFrame.from_dict({'a': {0: 14, 1: 0, 2: 105, 3: 67},'b': {0: 67, 1: 0, 2: 0, 3: 63},'c': {0...
python中row函数怎么用,Excel Row函数和Rows函数的使用方法，含Row(A:A)与Row(1:1)实例...
weixin_31560425的博客
03-25 1万+
在 Excel 中，Row函数用于返回单元格的行号，Rows函数用于返回数组或引用单元格的行数。如果Row函数省略参数，默认返回公式所在单元格的行号；Rows函数不能省略参数。Rows函数常与Indirect函数、Index函数、If函数、Match函数、SumProduct函数、Mod函数组合使用。以下是 Excel Row函数和Rows函数的使用方法，共列举有5个实例，包含Row(A:A)、R...
Python基础入门教程 Python语言编程导论 Python应用案例1 （共12页）.ppt
09-25
【Python基础入门教程 Python语言编程导论】课程列表 Python基础入门教程 Python语言编程导论 Python应用案例1 （共12页）.ppt Python基础入门教程 Python语言编程导论 Python应用案例二 （共24页）.ppt Python基础...
python基础教程 第三版 中文 高清 pdf
11-15
第1 章 快速上手：基础知识 1.1 交互式解释器 1.2 算法是什么 1.3 数和表达式 1.4 变量 1.5 语句 1.6 获取用户输入 1.7 函数 1.8 模块 1.8.1 cmath和复数 1.8.2 回到未来 1.9 保存并执行程序 1.9.1 从...
python基础代码大全
07-23
"Python基础代码大全"这个资源集成了许多初学者在学习Python时可能会遇到的基本概念和常见问题的实例代码，旨在帮助他们快速理解和掌握Python编程。 首先，Python的基础语法包括变量定义、数据类型如整型(int)、...
python规范_Python风格规范
weixin_39790877的博客
11-25 152
分号不要在行尾加分号, 也不要用分号将两条命令放在同一行.行长度每行不超过80个字符不要使用反斜杠连接行.Python会将 圆括号, 中括号和花括号中的行隐式的连接起来 , 你可以利用这个特点. 如果需要, 你可以在表达式外围增加一对额外的圆括号.缩紧绝对不要用tab, 也不要tab和空格混用.对于行连接的情况, 你应该要么垂直对齐换行的元素(见 行长度 部分的示例), 或者使用4空格的悬挂式缩进...
python每日练习01
一个小白
07-21 249
“”" 用python输出以下图形 * ** ** “”" row = int(input(“请输入行数：”)) for i in range(row): for j in range(i+1): print("*",end="") print() row = int(input(“请输入行数：”)) for i in range(row): for j in rang...
python笔记1
ph1ght的专栏
03-31 5381
python笔记1
python里row是什么意思_row python
weixin_39769675的博客
12-08 7330
1、python脚本中经常第一句出现#!/usr/bin/env python或#!/usr/bin/python。这句话的意义下面解释：脚本语言的第一行，目的就是指出，你想要你的这个文件中的代码用什么可执行程序去运行它，就这么简单!/usr/bin/python是告诉操作系统执行这个脚本的时候，调用/usr/bin下的python解释器；!/usr/bin/env python这种用法是为了防止...
python row函数_带你一起学Python-4-Python模块化编程
weixin_29008805的博客
01-23 2694
在前面的几篇推文中已经学习了Python中的数据结构、分支结构、循环结构、函数、面向对象编程。到现在为止，我们已经可以做很多的事情了。如果有编程经验的朋友肯定会想到一个问题：到目前为止，我们所有的代码都是放在一个.py文件中的。很明显这不符合我们模块化开发的思想。什么是Python模块？Python模块是一个.py文件，我们可以把我们定义的函数、类、变量放在一个.py文件中。然后在另一个.py文件...
Excel Row函数和Rows函数的使用方法，含Row(A:A)与Row(1:1)实例
weixin_30279315的博客
05-09 3万+
在 Excel 中，Row函数用于返回单元格的行号，Rows函数用于返回数组或引用单元格的行数。如果Row函数省略参数，默认返回公式所在单元格的行号；Rows函数不能省略参数。Rows函数常与Indirect函数、Index函数、If函数、Match函数、SumProduct函数、Mod函数组合使用。以下是 Excel Row函数和Rows函数的使用方法，共列举有5个实例，包含Row(A:A)、R...
【python 分组标记】python实现row_number功能
赖德发的博客
04-25 5426
假设数据集data_101如下： content source_id max_similar 0 东篱 1 1.0 1 东篱 2 1.0 2 在么 3 1.0 3 在么 4 1.0 4 快回我 ...
python关于row的规范_将规范化的一对多单行数据转成1对1单行数据（全部代码）...
weixin_39697660的博客
12-16 805
[python]代码库import randomimport csv# 生成随机csv表文件，做实验用def gen_csv(filename):# csv文件数据datas = []# csv文件表头data_header = ['组名']# 每一组最多可以有10个组员for i in range(10):data_header.append('组员'+str(i))# 先加表头datas.ap...
python中[-1]、[:-1]、[::-1]、[n::-1]使用方法
热门推荐
qq_21840201的博客
12-18 9万+
import numpy as np a=np.random.rand(5) print(a) [ 0.64061262 0.8451399 0.965673 0.89256687 0.48518743] print(a[-1]) ###取最后一个元素 [0.48518743] print(a[:-1]) ### 除了最后一个取全部 [ 0.64061262 0.84513...
Python基础入门教程
"这是一份Python基础教程的摘录，涵盖了Python语言的基本概念、环境配置、编程基础以及一些进阶特性。" 这篇Python基础教程详细介绍了学习Python编程所需的关键知识点。首先，它提及了Python的版本，暗示了教程可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值