<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[QWSADAW122312的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/QWSADAW122312</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; QWSADAW122312]]></copyright><item><title><![CDATA[线程其他相关用法和守护线程]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258560</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258560</guid><author>QWSADAW122312</author><pubDate>Tue, 17 Sep 2019 20:31:00 +0800</pubDate><description><![CDATA[线程其他相关用法和守护线程
线程其他相关用法
from threading import Thread,currentThread,enumerate,activeCount
# import threading
import time
# threading.current_thread()
# threading.current_thread()

def task():
    p...]]></description><category></category></item><item><title><![CDATA[线程的join方法]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258557</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258557</guid><author>QWSADAW122312</author><pubDate>Tue, 17 Sep 2019 20:31:00 +0800</pubDate><description><![CDATA[线程的join方法
方法一：
from threading import Thread
import time
def task():
  print('子线程 start')
  time.sleep(2)
  print('子线程 end')
  
  
t = Thread(target=task)
t.start()
t,join()# 等待子线程运行结束
print('主线程'...]]></description><category></category></item><item><title><![CDATA[子线程资源共享]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258558</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258558</guid><author>QWSADAW122312</author><pubDate>Tue, 17 Sep 2019 20:30:00 +0800</pubDate><description><![CDATA[子线程资源共享
from threading import Thread
import time ,os

x = 100
def task():
  global x
  x = 50
  print(os.getpid())#20456
  
if __name__ == '__main__':
    t = Thread(target = task)
    t.start()
...]]></description><category></category></item><item><title><![CDATA[# 子线程和子进程的创建速度]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258556</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258556</guid><author>QWSADAW122312</author><pubDate>Tue, 17 Sep 2019 20:30:00 +0800</pubDate><description><![CDATA[子线程和子进程的创建速度
from threading import Thread
from mutlprocessing import Process
import time

def task(name):
  print(f'{name} is running')
  time.sleep(2)
  print(f'{name} is end')
  
  
if __name__...]]></description><category></category></item><item><title><![CDATA[开启线程的两种方式]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258555</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258555</guid><author>QWSADAW122312</author><pubDate>Tue, 17 Sep 2019 20:29:00 +0800</pubDate><description><![CDATA[开启线程的两种方式
方式一：
from threadong import Thread
import time

def task():
  print('线程 start')
  time.sleep(2)
  print('线程 end')
  
  
if __name__ == '__main__':
    t = Thread(target = task)
  t.start...]]></description><category></category></item><item><title><![CDATA[线程内容]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258554</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258554</guid><author>QWSADAW122312</author><pubDate>Tue, 17 Sep 2019 20:29:00 +0800</pubDate><description><![CDATA[线程内容
一、初识别线程.
在传统操作系统中，每一个进程中有一个地址空间，而且默认就有一个控制线程，cpu真正的执行单位是线程。
在工厂中，每一个车间都有房子，而且每个车间默认就有一条流水线
操作系统 ---&gt; 工厂
进程 ---&gt;车间
线程 ---&gt; 流水线
cpu ---&gt; 电源
线程：cpu最小的执行单位
进程：资源集合、资源单位
线程运行 = 运行代码
进...]]></description><category></category></item><item><title><![CDATA[反射]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258553</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258553</guid><author>QWSADAW122312</author><pubDate>Mon, 16 Sep 2019 18:29:00 +0800</pubDate><description><![CDATA[用户输入一段字符串，执行该字符串对应的方法
hasattr():判断一个属性是否在对象中，返回True或者False
getattr():通过字符串获取属性或者方法，如果获取收到了，就会返回相应的属性和方法
setattr():通过字符串来设置属性或方法
delattr():通过字符串来删除属性或方法
class Foo:
  def run(self):
            pri...]]></description><category></category></item><item><title><![CDATA[同步异步阻塞非阻塞]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258552</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258552</guid><author>QWSADAW122312</author><pubDate>Mon, 16 Sep 2019 18:28:00 +0800</pubDate><description><![CDATA[一、状态介绍

在了解其他概念之前，我们首先要了解进程的几个状态。在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态：就绪，运行和阻塞。

就绪(Ready)状态：当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。
执行/运行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。
...]]></description><category></category></item><item><title><![CDATA[通过元类控制类的产生]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258551</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258551</guid><author>QWSADAW122312</author><pubDate>Mon, 16 Sep 2019 18:27:00 +0800</pubDate><description><![CDATA[自定义元类：来控制类的产生：可以控制类名，可以控制类的集成父类，控制类的名称空间
type
自定义元类必须集成type,写一个类继承type 这种类都叫元类
class Mymeta(type):
  #def __init__(self,*args,**kwargs):
  def __init__(self,name,bases,dic):
    #sef就是Person类
   ...]]></description><category></category></item><item><title><![CDATA[通过元类控制类的调用过程]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258550</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258550</guid><author>QWSADAW122312</author><pubDate>Mon, 16 Sep 2019 18:27:00 +0800</pubDate><description><![CDATA[__call__
控制类的调用过程，实际上在控制：对象的产生
class Mymeta(type):
  def __call__(self,*args,**kwargs):
    #print('xxx')
    return 1
class Person(object,metaclass=Mymeta):
  school = 'oldboy'
  def __init__(se...]]></description><category></category></item><item><title><![CDATA[并发编程（初学）]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258549</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258549</guid><author>QWSADAW122312</author><pubDate>Mon, 16 Sep 2019 18:27:00 +0800</pubDate><description><![CDATA[一、手工操作-------穿孔卡片
1946年第一台计算机诞生--20世纪50年代中期，计算机工作还在采用手工操作的方式。此时还没有操作系统的概念。


程序员将对应程序和数的已穿孔的指代（或卡片）装入输入机，然后启动输入机把程序和数据输入计算机内存，接着通过控制台开关启动程序针对数据运行：计算完毕，打印机输出计算机结果；用户取走结果并卸下纸带（或卡片）后，才让下一个用户上机。
手工操作...]]></description><category></category></item><item><title><![CDATA[class底层原理分析]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258473</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258473</guid><author>QWSADAW122312</author><pubDate>Mon, 16 Sep 2019 18:27:00 +0800</pubDate><description><![CDATA[class 类名 会把类构造出来
实际上是：元类实例化产生类 这个对象
类实例化产生对象，一定是： 类名()
Person 类是由type实例化产生，传一堆参数
type() 调用类的__init__方法
type()
type(object_or_name,bases,dict)
object_or_name 类的名字，是个字符串
bases:是它的所有的父类，基类
dict :名称空...]]></description><category></category></item><item><title><![CDATA[什么是元类]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258548</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258548</guid><author>QWSADAW122312</author><pubDate>Mon, 16 Sep 2019 18:26:00 +0800</pubDate><description><![CDATA[一切皆对象：类实际上就是一个对象
Person类也是一个对象，那他一定是由一个类实例化得到的，这个类就是元类
type是内置的一个元类，所有的类都是由type实例化得到的
产生类的类叫做元类

class Person:
  def __init__(self,name):
    self.name = name
    def score(self):
    print('分数是1...]]></description><category></category></item><item><title><![CDATA[函数的返回值]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258547</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258547</guid><author>QWSADAW122312</author><pubDate>Thu, 08 Aug 2019 21:05:00 +0800</pubDate><description><![CDATA[函数的返回值
一、什么是返回值?
函数内部代码经过一些逻辑处理获得的结果。
def func():
  name = 'nick'
  return name

name = func()
print(name)
nick
二、为什么要有返回值？
现在有一个需求，比较两个人的月薪，然后想获取月薪较大的人的年薪。如果需要在程序中拿到函数的处理结果作进一步的处理，则需要函数必须要有返回值。
...]]></description><category></category></item><item><title><![CDATA[函数的定义]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258546</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258546</guid><author>QWSADAW122312</author><pubDate>Thu, 08 Aug 2019 21:05:00 +0800</pubDate><description><![CDATA[函数的定义
一、函数体系
接下来，我们将按照这个函数体系给大家详细的介绍函数：

什么是函数？
为什么要用函数？
函数的分类：内置函数与自定义函数
如何自定义函数

语法
定义有参函数，及有参函数的应用场景
定义无参函数，及无参函数的应用场景
定义空函数，及空函数的应用场景

调用函数

如何调用函数
函数的返回值
函数参数的应用：形参和实参，位置形参，位置实参，关键字实参，关键字形参，...]]></description><category></category></item><item><title><![CDATA[函数的调用]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258545</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258545</guid><author>QWSADAW122312</author><pubDate>Thu, 08 Aug 2019 21:04:00 +0800</pubDate><description><![CDATA[函数的调用
一、什么是函数调用？
第一次将函数其实就讲了韩式的调用，但是你不得不再次更新你对函数调用的印象。
函数名(...)即调用函数，汇之星函数体代码，直到碰到return或者执行完函数体内所有代码结束。
函数运行完毕所有代码，如果函数体不写return，则会返回None。
def foo():
  pass

print(foo())
None
二、为何要调用函数？
一个非常愚蠢的...]]></description><category></category></item><item><title><![CDATA[定义函数的三种形式]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258544</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258544</guid><author>QWSADAW122312</author><pubDate>Thu, 08 Aug 2019 21:04:00 +0800</pubDate><description><![CDATA[定义函数的三种形式
一、无参函数
定义函数时参数是函数体接受外部传值的一种没接，其实就是一个变量名
在函数阶段括号内没有参数，称为无参函数。需要注意的是：定义时无参，意味着调用时也无需传入参数。
如果函数体代码逻辑不需要依赖外部传入的值，必须得定义成无参函数。
def func():
  print('hello nick')
  
func()  #  hello nick  
二、有...]]></description><category></category></item><item><title><![CDATA[with管理文件的上下文]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258543</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258543</guid><author>QWSADAW122312</author><pubDate>Thu, 08 Aug 2019 21:03:00 +0800</pubDate><description><![CDATA[with管理文件的上下文
之前我们使用open()方法操作文件，但是open打开文件后我们还需要手动释放文件对操作系统的占用。但是其实我们可以更方便的打开文件，即Python提供的上下文管理工具——with open()。
with open('32.txt', 'rt', encoding='utf8') as f:
    print(f.read())
sdf
with open(...]]></description><category></category></item><item><title><![CDATA[文件修改的两种方式]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258542</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258542</guid><author>QWSADAW122312</author><pubDate>Thu, 08 Aug 2019 21:02:00 +0800</pubDate><description><![CDATA[文件修改的两种方式
文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说，我们平时看到的修改文件，都是模拟出来的效果，具体的说有两种实现方式。
方式一
将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）。
import os

with open('37r.txt') as fr, \
  ...]]></description><category></category></item><item><title><![CDATA[字符编码]]></title><link>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258475</link><guid>https://blog.youkuaiyun.com/QWSADAW122312/article/details/101258475</guid><author>QWSADAW122312</author><pubDate>Thu, 08 Aug 2019 21:02:00 +0800</pubDate><description><![CDATA[字符编码
一、计算机基础

二、文本编辑器存取文件的原理

打开编辑器就打开了启动一个进程，是在内存中的，所以，用编辑器编写的内容也都是存放在内存中的，断电后数据丢失。
都想要永久保存，需要点击按钮：编辑器吧内存的数据刷到了硬盘上。
在我们编写一个py文件（没有执行），跟编写其他文件没有任何区别，都是在编写一堆字符而已

三、Python解释器执行PY文件的原理

第一阶段：python...]]></description><category></category></item></channel></rss>