首页 文章 精选 留言 我的

精选列表

搜索[学习]，共10003篇文章
优秀的个人博客,低调大师

Python 学习(六)

1. 正则表达式 re 模块使 Python 语言拥有全部的正则表达式功能。 1). re.match函数 re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。 函数语法： re.match(pattern, string, flags=0) 函数参数说明： pattern : 匹配的正则表达式 string : 要匹配的字符串 flags : 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。 # 正则表达式 import re # 在起始位置开始匹配 print(re.match("www","www.baidu.com").span()) # 不在起始位置开始匹配 print(re.match("com","www.baidu.com")) 图1.png 2). 使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。 group(num=0)：匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组 groups()：返回一个包含所有小组字符串的元组，从 1 到 所含的小组号 # group import re # 字符串 line = "Cats are smarter than dogs" # 正则匹配 matchObj = re.match(r'(.*) are (.*?) .*', line, re.M|re.I) # 判断是否匹配成功 if matchObj: print("matchObj.group(): ", matchObj.group()) print("matchObj.group(1): ", matchObj.group(1)) print("matchObj.group(2): ", matchObj.group(2)) pass else: print("No match!") 打印结果： 图2.png 3). re.search方法 re.search 扫描整个字符串并返回第一个成功的匹配。 函数语法： re.search(pattern, string, flags=0) 函数参数说明： pattern : 匹配的正则表达式 string : 要匹配的字符串 flags : 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 import re # 在起始位置匹配 print(re.search("www","www.baidu.com").span()) # 不在起始位置匹配 print(re.search("com","www.baidu.com").span()) 打印结果： 图3.png 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。 group(num=0)：匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 groups()：返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 import re line = "Cats are smarter than dogs" searchObj = re.search(r"(.*) are (.*?) .*", line, re.M|re.I) if searchObj: print("searchObj.group(): ", searchObj.group()) print("searchObj.group(1): ", searchObj.group(1)) print("searchObj.group(2): ", searchObj.group(2)) pass else: print("Nothing found!") pass 打印结果： 图4.png 4). re.match与re.search的区别 re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。 5). 检索和替换 Python 的re模块提供了re.sub用于替换字符串中的匹配项。 语法： re.sub(pattern, repl, string, count=0) 参数： pattern : 正则中的模式字符串。 repl : 替换的字符串，也可为一个函数。 string : 要被查找替换的原始字符串。 count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。 repl为字符串示例： import re phone = "2004-959-559 # 这个一个电话号码" # 删除注释 num = re.sub(r'#.*$', "", phone) print("电话号码：", num) # 移除非数字内容 num = re.sub(r'\D', "", phone) print("电话号码：", num) 打印结果： 图5.png repl为函数示例： # 将匹配的数字乘于2 def double(matched): value = int(matched.group('value')) return str(value*2) pass s = "A23G4HF56" print(re.sub("(?P<value>\d+)", double, s)) 打印结果： 图6.png 6). compile 函数 compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。 语法格式为： re.compile(pattern[, flags]) 参数： pattern : 一个字符串形式的正则表达式 flags 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为： 1> re.I 忽略大小写 2> re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境 3> re.M 多行模式 4> re.S 即为' . '并且包括换行符在内的任意字符（' . '不包括换行符） 5> re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库 6> re.X 为了增加可读性，忽略空格和' # '后面的注释 示例： import re # 用于匹配至少一个数字 pattern = re.compile(r'\d+') # 查找头部，没有匹配 m = pattern.match('one12twothree34four') # 打印 print(m) # 从‘e’的位置开始匹配，没有匹配 m = pattern.match('one12twothree34four', 2, 10) print(m) # 从‘1’的位置开始匹配，正好匹配 m = pattern.match('one12twothree34four', 3, 10) print(m) # group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)； print(m.group(0)) # start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0； print(m.start(0)) # end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0； print(m.end(0)) # span([group]) 方法返回 (start(group), end(group))。 print(m.span(0)) 打印结果： 图7.png 7). findall 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。注意： match 和 search 是匹配一次 findall 匹配所有。 语法格式为： findall(string[, pos[, endpos]]) 参数： string 待匹配的字符串。 pos 可选参数，指定字符串的起始位置，默认为 0。 endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。 import re # 查找数字 pattern = re.compile(r'\d+') result1 = pattern.findall('runoob 123 google 456') result2 = pattern.findall('runoob123google456', 0, 10) print(result1) print(result2) 打印结果： 图8.png 8). finditer 和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。 re.finditer(pattern, string, flags=0) 参数： pattern : 匹配的正则表达式 string : 要匹配的字符串 flags : 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 import re it = re.finditer(r"\d+","12a32bc43jf3") for match in it: print(match.group()) pass 打印结果： 图9.png 2. CGI(Common Gateway Interface) CGI(Common Gateway Interface),通用网关接口,它是一段程序,运行在服务器上如：HTTP服务器，提供同客户端HTML页面的接口。 1). 网页浏览 为了更好的了解CGI是如何工作的，我们可以从在网页上点击一个链接或URL的流程： 1、使用你的浏览器访问URL并连接到HTTP web 服务器。 2、Web服务器接收到请求信息后会解析URL，并查找访问的文件在服务器上是否存在，如果存在返回文件的内容，否则返回错误信息。 3、浏览器从服务器上接收信息，并显示接收的文件或者错误信息。 CGI程序可以是Python脚本，PERL脚本，SHELL脚本，C或者C++程序等。 2). CGI架构图 图10-CGI架构图 3). 程序 #!D:\java\python\python.exe import cgi form=cgi.FieldStorage() name=form.getvalue('name','world') print """Content-type:text/html <html> <head> <title>Greeting Page</title> </head> <body> <h1>Hello.%s!</h1> <form action='simple3.cgi'> Change name <input type='text' name='name'/> <input type='submit' /> </form> </body> </html> """%name
2018-04-10
优秀的个人博客,低调大师

Python 学习(五)

1. 错误与异常 1). try语句按照如下方式工作； 首先，执行try子句（在关键字try和关键字except之间的语句）;如果没有异常发生，忽略except子句，try子句执行后结束; 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码; 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中;一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行; 处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常; 一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如: except (RuntimeError, TypeError, NameError): pass 最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。 示例： import sys try: f = open('myfile.txt') s = f.readline() i = int(s.strip()) pass 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]) pass 打印结果： 图1.png 2). try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。 for arg in sys.argv[1:]: try: f = open(arg, 'r') except IOError: print('cannot open', arg) else: print(arg, 'has', len(f.readlines()), 'lines') f.close() 3). 抛出异常 raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）.如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。 try: raise NameError('HiThere') except NameError: print('An exception flew by!') raise 4). 用户自定义异常 通过创建一个新的exception类来拥有自己的异常。异常应该继承自 Exception 类，或者直接继承，或者间接继承 class MyError(Exception): def __init__(self, value): self.value = value def __str__(self): return repr(self.value) 5). 定义清理行为 try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 try: raise KeyboardInterrupt finally: print('Goodbye, world!') 6). 预定义的清理行为 一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。 with open("myfile.txt") as f: for line in f: print(line, end="") 2. 面向对象技术简介 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。 实例变量：定义在方法中的变量，只作用于当前实例的类。 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。 实例化：创建一个类的实例，类的具体对象。 方法：类中定义的函数。 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。 3. 类定义 语法格式如下： class ClassName: <statement-1> . . . <statement-N> 类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。 4. 类对象 类对象支持两种操作：属性引用和实例化。属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。类对象创建后，类命名空间中所有的命名都是有效属性名。 # 定义类 class MyClass(object): """一个简单的类实例""" i = 123 def f(self): return "Hello World!" pass # 实例化类 x = MyClass() # 访问类的属性和方法 print("MyClass 类的属性 i 为：", x.i) print("MyClass 类的方法 f 输出：", x.f()) 打印结果： 图2.png 5. 构造函数__init__() self代表类的实例，而非类，类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的: # 定义类 class Complex(object): """docstring for Comples""" def __init__(self, realpart, imagpart): super(Complex, self).__init__() self.r = realpart self.i = imagpart # 创建类 x = Complex(3.0, -2.4) print(x.r, x.i) 打印结果： 图3.png 6. 类的方法 在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。 # 类定义 class people(object): """docstring for people""" # 定义基本属性 name = "" age = 0 # 定义私有属性， 私有属性在类外部无法直接访问 __weight = 0 # 定义构造方法 def __init__(self, name, age, weight): super(people, self).__init__() self.name = name self.age = age self.__weight = weight def speak(self): print("%s 说：我 %d 岁。" %(self.name, self.age)) pass # 实例化类 p = people("mazaiting", 24, 60) p.speak() 打印结果： 图4.png 7. 继承 Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示: class DerivedClassName(BaseClassName1): <statement-1> . . . <statement-N> 需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法。 BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用: class DerivedClassName(modname.BaseClassName): 示例： # 类定义 class people(object): """docstring for people""" # 定义基本属性 name = "" age = 0 # 定义私有属性， 私有属性在类外部无法直接访问 __weight = 0 # 定义构造方法 def __init__(self, name, age, weight): super(people, self).__init__() self.name = name self.age = age self.__weight = weight def speak(self): print("%s 说：我 %d 岁。" %(self.name, self.age)) pass # 单继承 class student(people): """docstring for student""" grade = "" def __init__(self, name, age, weight, grade): super(student, self).__init__(name, age, weight) self.grade = grade # 复写父类方法 def speak(self): print("%s 说：我 %d 岁了，我在读 %d年级" %(self.name, self.age, self.grade)) pass s = student("John", 12, 40, 6) s.speak() 打印结果： 图5.png 8. 多继承 Python同样有限的支持多继承形式。多继承的类定义形如下例: class DerivedClassName(Base1, Base2, Base3): <statement-1> . . . <statement-N> 需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。 # 类定义 class people(object): """docstring for people""" # 定义基本属性 name = "" age = 0 # 定义私有属性， 私有属性在类外部无法直接访问 __weight = 0 # 定义构造方法 def __init__(self, name, age, weight): super(people, self).__init__() self.name = name self.age = age self.__weight = weight def speak(self): print("%s 说：我 %d 岁。" %(self.name, self.age)) pass # 单继承 class student(people): """docstring for student""" grade = "" def __init__(self, name, age, weight, grade): super(student, self).__init__(name, age, weight) self.grade = grade # 复写父类方法 def speak(self): print("%s 说：我 %d 岁了，我在读 %d年级" %(self.name, self.age, self.grade)) pass # 演讲者类 class speaker(object): """docstring for speaker""" topic = "" name = "" def __init__(self, name, topic): # super(speaker, self).__init__() self.name = name self.topic = topic def speak(self): print("我叫%s, 我是一个演说家，我演讲的主题是%s"%(self.name, self.topic)) pass # 多重继承 class sample(speaker, student): """docstring for sample""" def __init__(self, name, age, weight, grade, topic): student.__init__(self, name, age, weight, grade) speaker.__init__(self, name, topic) test = sample("mazaiting", 24, 60, 6, "Python") # 方法名同， 调用的是在括号中排前的父类的方法 test.speak() 打印结果： 图6.png 9. 方法重写 如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法 # 方法重写 # 定义父类 class Parent(object): """docstring for Parent""" def myMethod(self): print("调用父类方法") pass # 定义子类 class Child(object): """docstring for Child""" def myMethod(self): print("调用子类方法") pass # 子类实例 c = Child() # 子类调用重写方法 c.myMethod() 打印结果： 图7.png 10. 类属性与方法 类的私有属性 __private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。 类的方法 在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。 self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。 类的私有方法 __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__private_methods。 私有属性示例： # 定义类 class JustCounter(object): """docstring for JustCounter""" # 私有变量 __secretCount = 0 # 公开变量 publicCount = 0 def count(self): self.__secretCount += 1 self.publicCount += 1 print(self.__secretCount) pass counter = JustCounter() counter.count() counter.count() print(counter.publicCount) # 报错，实例不能访问私有变量 print(counter.__secretCount) 打印结果： 图8.png 私有方法示例： class Site(object): """docstring for Site""" def __init__(self, name, url): super(Site, self).__init__() # public self.name = name # private self.__url = url def who(self): print("name: ", self.name) print("url: ", self.__url) pass # 私有方法 def __foo(): print("这是私有方法") pass # 公共方法 def foo(self): print("这是公共方法") self.__foo() pass x = Site("百度", "www.baidu.com") x.who() x.foo() # 报错 x.__foo() 打印结果： 图9.png 11. 类的专有方法： init : 构造函数，在生成对象时调用 del : 析构函数，释放对象时使用 repr : 打印，转换 setitem : 按照索引赋值 getitem: 按照索引获取值 len: 获得长度 cmp: 比较运算 call: 函数调用 add: 加运算 sub: 减运算 mul: 乘运算 div: 除运算 mod: 求余运算 pow: 乘方 12. 运算符重载 Python同样支持运算符重载，我们可以对类的专有方法进行重载 # 运算符重载 class Vector(object): """docstring for Vector""" def __init__(self, a, b): super(Vector, self).__init__() self.a = a self.b = b def __str__(self): return "Vector (%d, %d)" % (self.a, self.b) pass def __add__(self, other): return Vector(self.a + other.a, self.b + other.b) pass v1 = Vector(2, 10) v2 = Vector(5, -2) print(v1 + v2) 打印结果： 图10.png
2018-04-09
优秀的个人博客,低调大师

Python 学习(二)

1. 数据类型 Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。多变量赋值：a = b = c = 1 或者 a, b, c = 1, 2, "mazaiting" Python中六个标准数据类型：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Sets（集合）、Dictionary（字典） Number（数字） 1). 数字类型有四种 int、float、bool、complex（复数）。 示例1： >>> a, b, c, d = 210, 4.4, True, 4+3j >>> print(type(a),type(b),type(c),type(d)) 打印结果1： 图1.png 示例2： >>> a = 11 >>> isinstance(a,int) 图2.png 区别: type()不会认为子类是一种父类类型。 isinstance()会认为子类是一种父类类型。 2). 删除对象引用del var 注意: 1、Python可以同时为多个变量赋值，如a, b = 1, 2。 2、一个变量可以通过赋值指向不同类型的对象。 3、数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。 4、在混合计算时，Python会把整型转换成为浮点数。 String（字符串） Python中的字符串用单引号'或双引号"括起来，同时使用反斜杠\转义特殊字符。 str = 'Mazaiting' print (str) # 输出字符串 print (str[0:-1]) # 输出第一个到倒数第二个的所有字符 print (str[0]) # 输出字符串第一个字符 print (str[2:5]) # 输出从第三个开始到第五个的字符 print (str[2:]) # 输出从第三个开始的后的所有字符 print (str * 2) # 输出字符串两次 print (str + "TEST") # 连接字符串 注意 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。 2、字符串可以用+运算符连接在一起，用*运算符重复。 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。 4、Python中的字符串不能改变。 List（列表） 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。列表是写在方括号([])之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。 示例1： # 列表数据 list = ['abcd', 784, 2.234, 'mazaiting', 20.2] # 短列表 tinylist = [234, 'zaitingma'] # 输出完整列表 print(list) # 输出列表第一个元素 print(list[0]) # 从第二个开始输出到第三个元素 print(list[1:3]) # 输出从第三个元素开始的所有元素 print(list[2:]) # 连续输出两次列表 print(tinylist * 2) # 连接列表 print(list + tinylist) 打印结果1： 图3.png 示例2： 修改列表数据： >>> a = [1, 2, 3, 4, 5] # 定义列表 >>> a[0] = 9 # 为第一个元素赋值 >>> a # 打印列表 [9, 2, 3, 4, 5] >>> a[2:5] = [14,13,14] # 修改第3-5个列表数据 >>> a # 打印 [9, 2, 14, 13, 14] >>> a[2:5] = [] # 将第3-5个数据置为空 >>> a # 打印 [9, 2] Tuple（元组） 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。 示例1： # 定义元组 tuple = ('abcd', 432, 3.32, 'mazaiting', 240.2) tinytuple = (123, 'zaitingma') # 输出完整元组 print(tuple) # 输出元组的第一个元素 print(tuple[0]) # 输出从第二个元素到第三个元素 print(tuple[1:3]) # 输出从第三个元素开始的所有元素 print(tuple[2:]) # 输出两次元组 print(tinytuple) # 连接元组 print(tuple+tinytuple) 打印结果1： 图4.png 示例2： >>> tup = (1, 2, 3, 4, 5, 6) >>> print(tup[0]) 1 >>> print(tup[1:5]) (2, 3, 4, 5) >>> tup[0] = 11 # 修改元组数据是非法的 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> string、list和tuple都属于sequence（序列）。 注意： 1、与字符串一样，元组的元素不能修改。 2、元组也可以被索引和切片，方法一样。 3、注意构造包含0或1个元素的元组的特殊语法规则。 4、元组也可以使用+操作符进行拼接。 Sets（集合） 1). 集合（set）是一个无序不重复元素的序列。 2). 基本功能是进行成员关系测试和删除重复元素。 3). 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。 示例： # 定义集合 student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'} # 输出集合，重复的元素被自动去掉 print(student) # 成员测试 if('Rose' in student) : print('Rose 在集合中') else : print('Rose 不在集合中') # set 可以进行集合运算 a = set('abracdabra') b = set('alacazam') print(a) # a和b的差集 print(a - b) # a和b的并集 print(a | b) # a和b的交集 print(a & b) # a和b不同时存在的元素 print(a ^ b) 打印结果： 图5.png Dictionary（字典） 字典（dictionary）是Python中另一个非常有用的内置数据类型。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。 示例： # 创建字典 dict = {} dict['one'] = "123" dict[2] = "23434" tinydict = {'name':'mazaiting','code':1,'site':'xibeixing'} # 输出键为'one'的值 print(dict['one']) # 输出键为2的值 print(dict[2]) # 输出完整的字典 print(tinydict) # 输出所有键 print(tinydict.keys()) # 输出所有值 print(tinydict.values()) 打印结果： 图6.png 注意： 1、字典是一种映射类型，它的元素是键值对。 2、字典的关键字必须为不可变类型，且不能重复。 3、创建空字典使用 { }。 2. 运算符 1). 逻辑运算符 and（和）、or（或）、not（非） 2). 成员运算符--用于判断某个元素是否在某个序列中存在 in：如果在指定的序列中找到值返回 True，否则返回 False。 not in：如果在指定的序列中没有找到值返回 True，否则返回 False。 3). 身份运算符--用于判断两个对象是否引用自同一对象 is：is 是判断两个标识符是不是引用自一个对象 x is y is not：is not 是判断两个标识符是不是引用自不同对象 3. 字符串 1). 字符串格式化 # 字符串格式化 print("我叫 %s 今年 %d 岁！" % ('mazaiting', 24)) 打印结果： 图7.png 2). 三引号 python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。 para_str = """ 这个一个多行字符串 多行字符串可以使用制表符 \t制表符 \n也可以使用换行符 """ print(para_str) 打印结果： 图8.png 4. 列表 # 创建列表 list1 = ['Google', 'mazaiting', 1204, 10.3] # 获取值 print('list1[0]:', list1[0]) # 追加元素 list1.append('1425941077') # 打印全部数据 print(list1) # 删除第一条数据 del list1[1] # 打印全部数据 print(list1) # 迭代 for x in [1,2,3]: print(x, end=" ") 打印结果： 图9.png 5. 元组 # 访问元组 tup1 = ('Google', 'Runoob', 1992, 2000) print ("tup1[0]: ", tup1[0]) # 修改元组.元素是不允许被修改的，但可以对元组进行拼接 tup2 = ('abc', 'xyz') tup3 = tup1 + tup2 print (tup3) # 删除元组.元组中的元素是不允许被删除的，但我们可以删除整个元组 del tup3 打印结果： 图10.png 6. 字典 字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示： d = {key1 : value1, key2 : value2 } 键必须是唯一的，但值则不必。 示例： # 访问字典里的值 dict = {'Name':"mazaiting", 'Age':24, 'Type':'Android'} print("dict['Name']:", dict['Name']) # 修改字典内容 dict['Type'] = 'JavaEE' print("dict['Type']", dict['Type']) # 删除字典元素 del dict['Name'] # 删除键'Name' print(dict) dict.clear() # 清空字典 print(dict) del dict # 删除字典 打印结果： 图11.png 字典键的特性: 1). 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住. 2). 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行.
2018-04-08
优秀的个人博客,低调大师

Python 学习(三)

1. 斐波纳契数列 # 两个元素的总和确定了下一个数 a, b = 0, 1 while b < 10: print(b) a, b = b, a + b pass 打印结果： 图1.png 2. end 关键字 关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符 # 两个元素的总和确定了下一个数 a, b = 0, 1 while b < 10: print(b, end=",") # 将文本输入在同一行 a, b = b, a + b pass 打印结果： 图2.png 3. 数字猜谜游戏 # 数字猜谜游戏 number = 7 guess = -1 print("数字猜谜游戏") while guess != number: guess = int(input("请输入你猜的数字: ")) if guess == number: print("恭喜你猜对了") elif guess < number: print("猜的数字小了") elif guess > number: print("猜的数字大了") pass 打印结果： 图3.png 4. 循环 while 循环 1). Python中while语句的一般形式： while 判断条件： 语句 同样需要注意冒号和缩进。另外，在Python中没有do..while循环 2). while 循环使用 else 语句 在 while … else 在条件语句为 false 时执行 else 的语句块： count = 0 while count < 5: print (count, " 小于 5") count = count + 1 else: print (count, " 大于或等于 5") for 语句 Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。 for循环的一般格式如下： for <variable> in <sequence>: <statements> else: <statements> 3). break和continue语句及循环中的else子句 break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 4). pass 语句 Python pass是空语句，是为了保持程序结构的完整性。 5. range()函数 如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列 for i in range(5): print(i) 6. 迭代器 迭代器有两个基本的方法：iter() 和 next() 1). iter()函数 list=[1,2,3,4] it = iter(list) # 创建迭代器对象 for x in it: print (x, end=" ") 2). next()函数 import sys # 引入 sys 模块 list=[1,2,3,4] it = iter(list) # 创建迭代器对象 while True: try: print (next(it)) except StopIteration: sys.exit() 7. 生成器 在 Python 中，使用了 yield 的函数被称为生成器（generator）。普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。 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()
2018-04-08
优秀的个人博客,低调大师

Python 学习(四)

1. 函数 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。 函数能提高应用的模块性，和代码的重复利用率。 定义函数的规则： 1). 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。 2). 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。 3). 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。 4). 函数内容以冒号起始，并且缩进。 5). return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。 语法： Python 定义函数使用 def 关键字，一般格式如下： def 函数名（参数列表）: 函数体 默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。 示例： # 计算面积函数 def area(width, height): return width * height pass w = 4 h = 5 print ("width = ", w, " height = ", h, " area = ", area(w,h)) 打印结果： 图1.png 2. 可更改(mutable)与不可更改(immutable)对象 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。 3. 参数 必需参数 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样 关键字参数 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。 默认参数 调用函数时，如果没有传递参数，则会使用默认参数。 不定长参数 基本语法如下： def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression] 加了星号（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。 示例： # 必需参数 def printStr(str): print(str) pass print("mazaiting") # 关键字参数 def printMe(str): print(str) pass printMe(str = "zaitingma") # 默认参数 def printInfo(name, age = 24): print("名字：", name) print("年龄：", age) pass printInfo(name = "mazaiting") # 不定长参数 def printInfo(arg, *vartuple): print("输出：") print(arg) for var in vartuple: print(var) pass pass printInfo(70, 60, 50) 打印结果： 图2.png 4. 匿名函数 所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。 1). lambda 只是一个表达式，函数体比 def 简单很多。 2). lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。 3). lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。 4). 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。 语法 lambda 函数的语法只包含一个语句，如下： lambda [arg1 [,arg2,.....argn]]:expression 示例： # lambda表达式 # 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数 print("相加后的值为：", sum(10, 20)) print("相加后的值为：", sum(20, 20)) 打印结果： 图3.png 5. return语句 return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None 示例： # return 语句 def sum(arg1, arg2): total = arg1 + arg2 return total pass # 调用sum函数 total = sum(10, 20) print("函数：",total) 打印结果： 图4.png 6. 变量作用域 Python的作用域一共有4种，分别是： 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 pass pass Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问. 当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字: global num = 1 def fun1(): global num # 需要使用 global 关键字声明 print(num) num = 123 print(num) fun1() nonlocal关键字 def outer(): num = 10 def inner(): nonlocal num # nonlocal关键字声明 num = 100 print(num) inner() print(num) outer() 7. 模块 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。 模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。 1). 引用标准库 示例： import sys print("命令行参数如下：") for i in sys.argv: print(i) pass print("\n\nPython 路径为：", sys.path, '\n') 打印结果： 图5.png 2). import 语句 想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下： import module1[, module2[,... moduleN] 当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。 示例： Support.py文件： def print_func(str): print("Hello: ", str) return Module.py文件 # 引入Support.py文件 # 导入模块 import Support # 调用Support中的函数 Support.print_func("Mazaiting") 图6.png 打印结果： 图7.png 3). From…import* 语句 把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明： from modname import * 这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。 4). name属性 一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用name属性来使该程序块仅在该模块自身运行时执行。 # Module.py if __name__ == '__main__': print("程序自身在运行") else: print("我来自另一模块") pass 打印结果： 图8.png 5). dir() 函数 内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回: 打印结果： 图9.png 8. 包 包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。 比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。 就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。 这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。 不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。 现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），所以你需要有一组不断增加的模块，用来在不同的格式之间转换。 并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），所以你还需要一组怎么也写不完的模块来处理这些操作。 这里给出了一种可能的包结构（在分层的文件系统中）: 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 ... 9. 输入输出 1). 输出 Python两种输出值的方式: 表达式语句和 print() 函数。 第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。 如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。 如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。 str()： 函数返回一个用户易读的表达形式 repr()： 产生一个解释器易读的表达形式 示例： # 返回一个用户易读的表达形式 x = str(1/7) print(x) # 产生一个解析器易读的表达形式 y = 100 * 100 print(repr(y)) # 格式话 print("{}网址：'{other}!'".format("百度",other="www.baidu.com")) 打印结果： 图10.png 2). 读键盘输入 # 从键盘输入 str = input("请输入：") print("你输入的内容是：", str) 打印结果： 图11.png 3). 读写文件 读文件:open() 将会返回一个 file 对象，基本语法格式如下: open(filename, mode) filename：filename 变量是一个包含了你要访问的文件名称的字符串值。 mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。只读(r), 二进制读(rb),读写(r+),二进制读写(rb+),写(w),二进制写(wb),读写(w+),二进制读写(wb+),追加(a),二进制追加(ab),读写追加(a+),二进制读写追加(ab+). 图12.png 写入文件示例： # 打开文件 file = open("test.txt","w") # 定义数据 str = "Python 是一个非常好的语言。" # 写入文件 file.write(str) # 关闭打开的文件 file.close 打印结果： 图13.png 读取文件示例： # 读取文件 file = open("test.txt", "r") # 读取数据 str = file.read() # 打印 print(str) # 关闭打开文件 file.close() 打印结果： 图14.png readline(): 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。 readlines(): 将返回该文件中包含的所有行。如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。 write(string)：将 string 写入到文件中, 然后返回写入的字符数。 tell()：返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。 seek()：如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。 from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如： seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符 seek(x,1) ： 表示从当前位置往后移动x个字符 seek(-x,2)：表示从文件的结尾往前移动x个字符 from_what 值为默认为0，即文件开头。 close(): 在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。 4). pickle 模块 python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。 基本接口： pickle.dump(obj, file, [,protocol]) 有了 pickle 这个对象, 就能对 file 以读取的形式打开: x = pickle.load(file) 注：从 file 中读取一个字符串，并将它重构为原来的python对象。存入数据示例： # 导入pickle import pickle # 使用pickle模块将数据对象保存到文件 data = { 'a':[1,2.3,4,5+6j], 'b':('string', u'Unicode string'), 'c':None } # 打开文件 output = open('data.pkl', 'wb') # 写入数据 pickle.dump(data, output) # 关闭文件 output.close() 写入数据示例： # 导入pickle import pprint,pickle # 使用pickle模块从文件中重构python对象 file = open('data.pkl','rb') # 重构对象 data = pickle.load(file) # 打印数据 pprint.pprint(data) # 关闭文件 file.close() 执行结果： 图15.png 10. 遍历文件夹 import os import os.path # 获取指定目录及其子目录下的py文件 l = [] def get_py(path, list): # 获取path目录下的所有文件 fileList = os.listdir(path) for fileName in fileList: # 获取path与fileName组合后的路径 pathTmp = os.path.join(path, fileName) # 如果是目录 if os.path.isdir(pathTmp): # 递归查找 get_py(pathTmp, list) pass # 不是目录，则比较后缀名 elif fileName[-3:].upper()=='.PY': list.append(pathTmp) pass pass pass path = input("请输入路径: ").strip() get_py(path, l) print("在%s目录及其子目录下找到%d个py文件\n分别为："%(path,len(l))) for filePath in l: print(filePath+'\n') pass 打印结果： 图16.png
2018-04-08
优秀的个人博客,低调大师

Python 学习(一)

1. 保留字 ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'] 查看方法： 图1.png 2. 打印 1). 写代码 # !/usr/bin/python3 # 第一个注释 print ("Hello, Python!") 图2.png 2). 命令行运行 python helloPython.py 打印结果： 图3.png 3. 注释 注释可以使用#进行单行注释或者'''和"""进行多行注释 # !/usr/bin/python3 # 第一个注释 print ("Hello, Python!") # 第一个注释 ''' 第二个注释 ''' """ 第三个注释 """ 图4.png 4. 缩进 python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。 if True: print ("True") else: print ("False") 图5.png 注： 缩进不一致，会导致运行错误 5. 多行语句 1). Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句 total = item_one + \ item_two + \ item_three 2). 在 [], {}, 或 () 中的多行语句，不需要使用反斜杠() total = ['item_one', 'item_two', 'item_three', 'item_four', 'item_five'] 6. 数据类型 1). 数字有四种类型：整数、布尔型、浮点数和复数 int(整数：1) boolean(布尔类型：true) float(浮点型：1.23) complex(复数：1.1+2.2j) 2). 字符串 - python中单引号和双引号使用完全相同。 - 使用三引号('''或""")可以指定一个多行字符串。 - 转义符 '\' - 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。 - 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。 - 字符串可以用 + 运算符连接在一起，用 * 运算符重复。 - Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。 - Python中的字符串不能改变。 - Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。 - 字符串的截取的语法格式如下：变量[头下标:尾下标] 示例： str='Mazaiting' # 输出字符串 print(str) # 输出第一个到倒数第二个的所有字符 print(str[0:-1]) # 输出字符串第一个字符 print(str[0]) # 输出从第三个开始到第五个字符 print(str[2:5]) # 输出从第三个开始的所有字符 print(str[2:]) # 输出字符串两次 print(str * 2) # 连接字符串 print(str + '你好') print('-----------------------------') # 使用反斜杠(\)+n转义特殊字符 print('hello\nworld') # 使用字符串前面添加一个r，表示原始字符串，不会发生转义 print(r'hello\nworld') 图6.png 打印结果： 图7.png 7. 等待用户输入 input("\n\n按下 enter 键后退出.") 8. 同一行显示多条语句 import sys; x = 'mazaiting'; sys.stdout.write(x + '\n') 9. 代码组 缩进相同的一组语句构成一个代码块，我们称之代码组。 像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。 我们将首行及后面的代码组称为一个子句(clause)。 if expression : suite elif expression : suite else : suite 10. 输出 x = "a" y = "b" # 换行输出 print(x) print(y) # 不换行输出 print(x, end = " ") print(y, end = " ") 打印结果： 图8.png 11. import 与 from...import 在 python 用 import 或者 from...import 来导入相应的模块。 将整个模块(somemodule)导入，格式为： import somemodule 从某个模块中导入某个函数,格式为： from somemodule import somefunction 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc 将某个模块中的全部函数导入，格式为： from somemodule import * 示例1： # 全部导入 import sys print('=====================Python import mode====================') print('命令行参数为：') for i in sys.argv: print(i) print ('\n Python 路径为 ', sys.path) 打印结果： 图9.png 示例2： # 导入sys模块的argv,path成员 from sys import argv,path print('=====================Python import mode====================') print ('path: ', path) 打印结果： 图10.png
2018-04-02
优秀的个人博客,低调大师

Python学习笔记

一：中文编码 1:指定编码 python-------》#!/usr/bin/python shell----------》#!/bin/bash 2:中文识别 # -*- coding: UTF-8 -*- 或 #coding=utf-8 3：多行语句 我们使用斜杠（/）将一行语句分成多行 如果是{},(),[]则直接可以进行换行 4.转义 \n表示换行、\t表示制表符、\\表示\、 如果有很多需要转义，则可使用r' ' ''' '''也可以表示换行 print('''line1 line2 line3''') 5：输出 print x,y print默认是换行的，如果再print末尾加个逗号“，”就回不换行 6.输入 shell：read -p "Please enter your age: " age python2：a = raw_input("请输入你的名字") python3：a = input("请输入你的名字") 二：变量和简单类型 python中数据类型分为5种：数字，字符串、列表、元组、字典 变量命名规则： python shell 文件名/模块名 小写，单词用“_”分割 ----->ad_stats.py 包名 小写，单词用“_”分割 类名 单词首字母大写----->ConfigUtil 全局变量名 大写字母，单词之间用_分割 ------->COLOR_WRITE 普通变量 小写字母，单词之间用_分割 ------->this_is_a_var 实例变量 以_开头，其他和普通变量一样 ----->_instance_var 普通函数 和普通变量一样-------------------->get_name() 2.1数字 整数：a=1 浮点数：a=1.234 2.2字符串 创：var1 = 'Hello World!' 查：print "var1[0]: ", var1[0] print "var2[1:5]: ", var2[1:5] 改：print "更新字符串 :- ", var1[:6] + 'Runoob!' rd()函数获取字符的整数表示，chr()函数把编码转换为对应的字符 占位符 'Hi, %s, you have $%d.' % ('Michael', 1000000) 如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串 另外一种格式化字符串的方法是format()，他会将传入的参数依次替换{1}，{2}，{3}......,... 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125) 2.3布尔值 布尔值只有True、False两种值 2.4空值 2.5常量 10/3=3.3333 9/3=3.0 10//3=3 10%3=1 2.6除法 余数： >>> divmod(10,3) (3, 1) 四舍五入： >>> round(10/3,4) 3.0 >>> round(10.0/3,4) 3.3333 2.7数学函数与运算优先级 1.绝对值 abs(-10)=10 2.四舍五入 round(1.234)=1 三：高级特性 1.切片 L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素 如果第一个索引是0，还可以省略-------》L[:3] 前10个数，每两个取一个----------》L[:10:2] 所有数，每5个取一个--------------》L[::5] 什么都不写，只写[:]就可以原样复制一个list-----------》L[:] 2.迭代 3.列表生成器 [x * x for x in range(1, 11)]--------》[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 四：列表（List） list是一种有序的集合，可以随时添加和删除其中的元素。 list1 = ['Michael', 'Bob', 'Tracy'] 增：list1.append('adm')、 list1.insert(1,'jack') #插入元素到指定的位置 删：list1.pop(1) #不填则删除末尾元素 del list1[2] 查：list1[-1] 改：list1[1] ='Sarah',dellist1[2]; 附加：s = ['python','java', ['asp','php'],'scheme'],s[2][1] 五：元组 Python的元组与列表类似，不同之处在于元组的元素不能修改。 tup1 = ('physics', 'chemistry', 1997, 2000); 查：tup1[2] 较：cmp(tuple1, tuple2) 长：len(tup1) 六：字典 字典是另一种可变容器模型，且可存储任意类型对象。 d = {key1 : value1, key2 : value2 } 增： 删：del d['key1']; # 删除键是'key1'的条目 d.pop(key1) #删除对应的键值对 d.clear(); # 清空词典所有条目 del d; # 删除词典 查：d['key1'] d.get(key1)---------->value1 d..has_key(key1)-------->返回true或者false d.keys()-------------->返回所以键['key2','key1'] dict.values()---------->返回所以值[value1,value2] 改：d['key1']=value3 d.update(dict2)----------->将dict2添加到d后面 判：d.has_key(key1)---------->存在则返回true，否则为false 较：cmp(dict1, dict2) 长：len(dict) 七：运算符 python中运算符分为7种：1.算术运算符 2.比较（关系）运算符 3.赋值运算符 4.逻辑运算符 5.位运算符 6.成员运算符 7.身份运算符 1.算术运算符：+、-、*、%（求余）、**（次幂a**b）、//(取整) 2.比较运算符：==（比较是否相等）、！=、<>（比较两个数是否不相等）、>=、<= 3.赋值运算符：=、+=、-=、*=、/=(除法赋值运算符)、%=（取模赋值运算符）、**=（幂赋值运算符）、//=（取整运算符） 4.位运算符：&、|、^、 5.and（与）、or（或）、not 6.in(在)、not in(不在) 7.is(是)、is not（不是） 优先级 八：语句 python分为7种：条件语句，循环语句（while循环，for循环），break语句，continue循环语句，pass循环 python循环语句不用括号（）括起来 1：条件语句 num = 5 if num == 3: # 判断num的值 print 'boss' elif num == 2:print 'user' elif num == 1:print 'worker' elif num < 0: # 值小于零时输出 print 'error' else:print 'roadman' # 条件均不成立时输出 2：循环语句 while...else循环 count = 0 while count < 5: print count, " is less than 5" count = count + 1 else: print count, " is not less than 5" for循环 for num in range(10,20): # 迭代 10 到 20 之间的数字 for i in range(2,num): # 根据因子迭代 if num%i == 0: # 确定第一个因子 j=num/i # 计算第二个因子 print '%d 等于 %d * %d' % (num,i,j) break # 跳出当前循环 else: # 循环的 else 部分 print num, '是一个质数' 九：函数 9.1函数规则 1：函数代码块以def关键字开头，后接函数标识符名称和圆括号（） 2：任何传入参数和变量必须放在圆括号中间，圆括号中可以用于定义参数 3：函数第一行语句可以放文档字符串，用于存放函数说明 4：函数内容以冒号起始，并且缩进 #python函数 def printinfo( name, age ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" ); #shell函数 function RintedConfig(){ } 9.2函数参数 1.必备参数、2.关键字参数、3.默认参数、4.不定长参数 1：必备参数 必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。 2：关键字参数 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。 def printinfo( name, age ): printinfo( age=50, name="miki" ); 3：缺省参数 调用函数时，缺省参数的值如果没有传入，则被认为是默认值。 def printinfo( name, age = 35 ): printinfo( name="miki" ); 4：不定长参数 你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数， def functionname([formal_args,] *var_args_tuple ): 加了星号（*）的变量名会存放所有未命名的变量参数 9.3高阶函数 1.map（） map（）可接受两个参数，一个是函数，一个是Iterable,map将传入的参数作用到序的每个元素，并把结果作为新的Iterable返回。 def f(x): return x*x map(f, [1,2,3,4]) >>[1,4,9,16] 2.return() return接收一个函数和两个参数,reduce把结果继续和序列的下一个元素做累积计算。 def f(x,y): return x+y >>map(f, [1,2,3,4]) >>25 3.filter() 用于过滤序列，filter（）将元素作用于每个人元素，并根据返回值是true或者false来决定元素的去留。 def is_odd(n): return n % 2==1 filter(is_odd, [1,2,3,4,5,6]) 4.sorted() sorted()可将元素进行排序， def reversed_cmp(x, y): if x > y: return -1 if x < y: return 1 return 0 >>> sorted([36, 5, 12, 9, 21], reversed_cmp) [36, 21, 12, 9, 5] 9.4返回函数 高阶函数除了可以将函数作为参数，也可以将函数作为结果返回。 def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum 9.5匿名函数 关键字lambda表示匿名函数， 匿名函数有个限制，就是只能使用一个表达式，返回值就是该表达式的结果。 map(lambda x: x*x, [1,2,3,4,5,6]) 使用匿名函数就不用担心名字冲突，同是匿名函数也是一个对象，可以将匿名函数作为参数。 ff = lambda x: x*x print ff(5) 9.6装饰器 有时候为了增强函数的功能，但又不改变函数的定义，这种在代码运行期间动态的增加函数的功能的方法叫装饰器。 def log(text): def decorator(func): def wrapper(*args, **kw): print('%s %s():' % (text, func.__name__)) return func(*args, **kw) return wrapper return decorator @log('execute') def now(): print('2015-3-25') >>> now() execute now(): 2015-3-25 9.7偏函数 十：模块 10.1作用域 有的函数和变量，我们仅仅希望在模块内使用，python中我们通过_前缀来实现。 正常的函数和变量都是被公开的，_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用。 带下划线的函数，说明该函数不能根据 from * import来导入，明显在这个模块中你导入的还只是包，然后通过了这个导入的包去调用他内部存在的函数。 十一：面向对象编程 11.1类和实例 class Student (Object): class后面接的是类名，类名手写字母必须大写，紧接的是object，表示该类所继承的类，如果没有，则继承自object类。 class Student(object): def __init__(self, name, score): self.name = name self.score = score def print_score(self): print '%s: %s' % (self.name, self.score) 11.2访问限制 如果要让内部属性，不被外部访问，可以将属性的名称前面加两个下划线，python中变量以__开头的则为私有变量（private），只有内部可以访问，外部不能被访问。 外部要获取和改变，只能通过get和set方法来进行。 class Student(object): def __init__(self, name, score): self.__name = name self.__score = score def print_score(self): print '%s: %s' % (self.__name, self.__score) #外部直接获取 >>> bart = Student('Bart Simpson', 98) >>> bart.__name Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute '__name'#必须使用getname和setname方法 class Student(object): ... def get_name(self): return self.__name def get_score(self): return self.__score 11.3基础多态 继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写； 有了继承，才能有多态。在调用类实例方法的时候，尽量把变量视作父类类型，这样，所有子类类型都可以正常被接收； 11.4获取对象信息 1.type（） type可以判断一个变量、函数，类的类型。 2.isinstance() isinstance()判断的是一个对象是否是该类型本身，或者位于该类型的父继承链上。 3.dir() 如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list。 11.5__slots__ 如果想对向前类进行限制只添加某几个属性，可以使用__slots__来进行限制。 __slots__只对当前类起作用，对继承的类不起作用。 class Student(object): __slots__=('name','age') s = Student() s.name = 'yaohong' s.age = 90 s.socre = 99 》》 s.socre = 99 AttributeError: 'Student' object has no attribute 'socre' 11.6@property Python内置的@property装饰器就是负责把一个方法变成属性调用的。 class Student(object): @property def birth(self): return self._birth @birth.setter def birth(self, value): self._birth = value @property def age(self): return 2014 - self._birth 11.7多继承 一个子类同时获得多个父类的所有功能。 由于Python允许使用多重继承，因此，Mixin就是一种常见的设计。 只允许单一继承的语言（如Java）不能使用Mixin的设计。 11.8定制类 __str__ class Student(object): def __init__(self, name): self.name = name def __str__(self): return self.name def __repr__(self): return self.name print Student('YAOHONG') print Student('YAOHONG') 11.9使用元类 十二：文件I/O 10.1打印到屏幕 print “”itnihao” 10.2读取输入 1.raw_input str = raw_input("请输入："); print "你输入的内容是: ", str 2.input input可以接收一个函数表达式 str = input("请输入："); print "你输入的内容是: ", str 3.open（） file object = open(file_name [, access_mode][, buffering]) file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。 access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。 buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。 4.close（） close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。 5.write（） write()方法可将任何字符串写入一个打开的文件 6.read（） fo = open("foo.txt", "r+") str = fo.read(10); print "读取的字符串是 : ", str # 关闭打开的文件 fo.close() 7.rename() os.rename( "test1.txt", "test2.txt" ) 8.remove() os.remove("test2.txt") 8.mkdri() os.mkdir("test")在当前目录下创建新的test文件 9.chdir（） os.chdir("/home/newdir")改变当前目录为/home/newdir目录 10.getcwd() os.getcwd()获取当前目录 11.rmdir（） # 删除”/tmp/test”目录 os.rmdir( "/tmp/test" ) 十三：异常处理 1.捕获异常：try/except try: fh = open("testfile", "w") fh.write("这是一个测试文件，用于测试异常!!") except IOError: print "Error: 没有找到文件或读取文件失败" else: print "内容写入文件成功" fh.close() 2.try/finally try-finally 语句无论是否发生异常都将执行最后的代码。 3.触发异常 使用raise语句自己触发异常 def functionName( level ): if level < 1: raise Exception("Invalid level!", level) # 触发异常后，后面的代码就不会再执行 十四：file file使用open函数来创建 常用函数： file.close() file.flush() file.next() 返回下一行 file.read(size) 从文件读取指定的字节数，如果未给定或为负则读取所有。 file.readline(size) 读取整行 file.seek() 设置文件当前位置 file.tell() 返回文件当前位置 file.truncate() 截取文件，截取文件通过size指定 file.write() 将指定字符串写入文件 file.writelines() 向文件写入一个字符串列表 十五：OS os.access() 检测文件是否可读可写，文件是否存在，是否拥有执行权限 os.chdir(path) 切换到新的目录 os.chmod() 更改文件或者目录权限 os.chown() 更改文件所有者 os.close() 关闭文件 os.path.join('a','b')字符串拼接形成a/b os.system("ls") 执行shell命令，如assert os.system("rm -rf %s" % install_path) == 0, "卸载 失败" os.path.exists(BIN_PATH) 判断某个变量是否存在 os.unlink(path) 方法用于删除文件,如果文件是一个目录则返回一个错误。 os.remove() 删除文件 十六：open open(a.txt).read() 去取a.txt文件 十七：enumerate enumerate(list1) 枚举list，map等获取索引和元素for index, item in enumerate(list1): 十八：string str.strip("@") 去掉以@开头结尾的 str.startswith("#") 判断是否以#开头 十九：Python常见模块 python常见命令如下，点击链接查看详情 1.os 2.os.path 3.shutil 4.sys 5.inspect
2018-03-26
优秀的个人博客,低调大师

Java学习笔记

代码点与代码单元 codePoint codeUnit 这里当字符串中有辅助字符时，代码点是两个代码单元，需要以下遍历： int cp = sentence.codePointAt(i); if(Character.isSupplementaryCodePoint(cp)){ i += 2; }else{ i++; } String类对象->不可变字符串 不能修改字符串中的字符：编译器可以将字符串共享，以此带来高效率。 当将一个字符串与一个非字符串的值进行拼接时，后者将被转换成字符串。 任何一个对象都可以转换成字符串。 检测两字符串是否相等，而不区分大小写，可用equalsIgnoreCase()方法 Java中允许一个数组长度为0，不同于null。 Java中的多维数组实际上是数组的数组。 一个对象变量实际上是一个对象指针。 用clone()方法获得对象的完整拷贝。 不能编写返回引用可变对象的访问器方法。 一个方法可以访问所属类的所有对象的私有数据。 Sytem类中有一个setOut方法是一个本地方法，不是用Java语言实现的，可以绕过Java的存取控制机制(out是final的)。 每个类都可以有一个main方法，可用来进行单元测试。 一个方法不能修改一个基本数据； 一个方法可以改变一个对象参数的状态； 一个方法不能让对象参数引用一个新的对象。 方法签名：方法名、参数类型。 初始化块机制 首先运行初始化快，然后才运行构造器的主体部分 静态域初始化块： static{ } 只能使用*导入一个包，如： import java.util.*; 静态导入：静态方法、静态域 import static java.lang.System.*; 如果没有指定public或private，那么这个部分（类、方法或者变量）可被同一个包中的所有方法访问 包作用域：默认情况下是包可见的 包密封:(package sealing) jar文件密封包 /*…/->文档注释 javadoc 标记+自由格式，其中标记由”@”开始 类设计技巧： 一定要将数据设为私有； 一定要对数据初始化； 不要在类中使用过多的基本数据类型； 不是所有的域都需要独立的域访问器和域更改器； 使用标准格式进行类的定义； 将职责过多的类进行分解； 类名和方法名要能够体现它们的职责。 Java中的所有继承都是公有继承：超类和子类 覆盖（Override）子类使用super调用超类的方法以及构造器 一个对象变量可以引用多种实际类型的现象叫做多态（Polymorphism） 运行能够自动地选择调用的适当方法的现象称为动态绑定 虚拟机预先为各个类创建了一个方法表 在覆盖一个方法时，子类方法不能低于超类方法的可见性 阻止继承的两种方法：final类的方法自动成为final方法（不包括域），final方法 内联的概念：如果一个方法没有被覆盖并且很短，编译器就能够对它进行优化处理。 强制类型转换： 只能在继承层次内进行类型转换； 在将超类转换成子类的前应使用instanceof进行检查 抽象类可以包含非抽象方法，也可以不包含抽象方法。抽象方法充当着占位的角色，具体实现在子类中。 抽象类不能被实例化 只有子类实现了所有抽象方法，子类才不是抽象的了 子类不能访问超类的私有域 hashcode: 由对象导出的一个整型值 每个对象都有一个默认的散列码，其值为对象的存储地址 两个相等的对象要求必须返回一个相等的散列码 自动打包规范要求boolean byte char=0:x; 四个基本的抽象流类：InputStream OutputStream Reader Writer(这些对象由其他方法返回) 注意流过滤器的运用 对象序列化：ObjectOutputstream ObjectInputStream writeObject() readObject() 类必须实现Serializable 接口 Java使用SHA编码的前8字节作为类的指纹 在序列化的过程中内存地址会被替换为序列号（唯一） 流类关注的是文件内容，而File类关注的是文件在磁盘上的存储 原文出处：后端技术杂谈 原文链接 转载请与作者联系，同时请务必标明文章原始出处和原文链接及本声明。
2018-02-09
优秀的个人博客,低调大师

CUDA学习（三）

内存层次结构：CUDA线程可能会在执行期间从多个内存空间访问数据，如图所示。每个线程都有专用本地内存(local menory)。 每个线程块都具有共享内存(shared memory)，该块的所有线程都可见，并且具有与该块相同的生命周期。 所有线程都可以访问相同的全局内存(global memory)。所有线程还有两个额外的只读内存空间：常量和纹理内存空间。 全局，常量和纹理内存空间针对不同的内存使用进行了优化。 对于某些特定的数据格式，纹理内存也提供了不同的寻址模式以及数据过滤功能。全局，常量和纹理内存空间在同一应用程序的内核启动时保持不变异构编程(Heterogeneous Programming):这里设GPU设备为Device，CPU设备为Host，如图所示，kernel函数在Device上运行，其余C语言程序依然上CPU上运行。CUDA编程模型还假定主机和设备都在DRAM中分别维护它们自己的独立存储空间，分别称为主机存储器和设备存储器。 因此，程序通过调用CUDA运行库来管理内核可见的全局，常量和纹理内存空间（在编程接口中描述）。 这包括设备内存分配和重新分配以及主机和设备内存之间的数据传输。统一内存提供托管内存来桥接主机和设备内存空间。 托管内存可以从系统中的所有CPU和GPU作为具有共同地址空间的单一连贯内存映像访问。 这种功能使得设备内存的超额申请成为可能，并且通过消除在主机和设备上显式镜像数据的需要，可以大大简化移植应用程序的任务。 计算能力：设备的计算能力由版本号表示，有时也称为“SM版本”。 该版本号标识GPU硬件支持的特征，并由运行时的应用程序使用以确定当前GPU上哪些硬件特征和指令可用。计算能力包括主版本号X和次版本号Y，用X.Y表示。主版本号相同的设备具有相同的核心架构。 基于Volta体系结构的设备主要版本为7，基于Pascal体系结构的设备为6，基于Maxwell体系结构的设备为5，基于开普勒体系结构的设备为3，基于费米体系结构的设备为2， 和基于特斯拉架构的设备为1.次要版本号对应于核心架构的渐进式改进，可能包括新功能。支持CUDA的GPU列出了所有支持CUDA的设备及其计算能力。 计算能力给出了每种计算能力的技术规格。特斯拉和费米架构分别在CUDA7.0和CUDA9.0不被支持。
2018-02-05

资源下载

更多资源
优质分享App

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

时间: 2025-12-03 大小: 4.36MB 下载: 23次
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2025-12-03 大小: 211.28KB 下载: 53次
Apache Tomcat

Apache Tomcat

Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web 应用服务器。

时间: 2025-12-03 大小: 10MB 下载: 35次
JDK

JDK

JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。

时间: 2025-12-03 大小: 180MB 下载: 76次
热门标签
K8s HarmonyOS NEXT SpringCloud SpringBoot 服务网格 Docker ChatGPT Nacos Redis Jdk25 DeepSeek

欢迎您！

登录后，您将获得更多功能！

热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273