开发工具和Python语言介绍

目录:

开发工具

  • Git
  • Python2.7/PIP
  • Pycharm

Python简介

  • 语法简介
  • 控制流
  • 数据结构
  • 面向对象
  • 异常
  • 随机数/正则表达式


PS:应该关注学习的方法论。


开发工具

一、Git

Gi分布式管理系统工具:Github/BitBucket


二、Python2.7/PIP


三、Pycharm


Python简介

一、语法简介

1 注释

1.1 单行注释

# 这是单行注释

1.2 多行注释

''' 这是
多行
注释 '''


2 字符串

str.split(sstr) # 将字符串str分割,以sstr为分隔符,缺省以空白符为分隔符,返回类型为列表
str.strip(sstr) # 将字符串str首尾的sstr全部移除,缺省以空白符为标准,返回类型字符串
str.lstrip() # 只移除str首部
str.rstrip() # 只移除str尾部
str.replace(str1, str2) # 将字符串中的str1替换成str2,返回类型字符串
str.startswith(sstr) # 判断字符串str是否以sstr开头,返回类型布尔类型
str.enswith(sstr) # 判断字符串str是否以sstr为结尾,返回类型布尔类型
str1+str2+str3 # 连接str1、str2、str3,返回类型字符串
len(str) # 计算字符串str的长度,返回类型整型
str.join(list/tuple) # 将列表/元组以str作为连接符连接,返回类型字符串
str.find(sstr) # 查找sstr在字符串str中的首字符的下标,返回类型整型,若未找到则返回-1


3 运算符

num1 | num2 # 返回num1与num2按位或的值
num1 & num2 # 返回num1与num2按位与的值
num1 ^ num2 # 返回num1与num2按位异或的值
arg1 and arg2 # 返回arg1或arg2,规则是从左到右演算表达式的值,若所有值为真则返回最后一个值,若某个为假则返回第一个假值
arg1 or arg2 # 返回arg1或arg2,规则是从左到右演算表达式的值,若某个为真则返回第一个真值,若全部为假则返回最后一个假值
not arg # 返回arg的相反的布尔值


4 变量

不需要声明变量类型,直接进行赋值;


5 内置函数

type(var) # 返回var的类型
max(arg1, arg2, ...) # 返回所有参数的最大值
min(arg1, arg2, ...) # 返回所有参数的最小值
cmp(obj1, obj2) # 比较obj1与obj2的大小,若大于返回1,若小于返回-1,若相等返回0
len(obj) # 返回对象obj的长度
range(start, stop, step) # 返回以start为开始、stop为结尾、step为步长构成的列表
abs(num) # 返回数字num的绝对值
dir(arg) # 返回参数的属性
eval(str) # 将字符串str当成有效的表达式来求值并返回计算结果
chr(num) # 返回num在ASCII码中对应的字符
ord(ch) # 返回字符ch在ASCII中对应的数值
divmod(num1, num2) # 返回num1对num2求余的值
open(name, mode) # 以mode格式将name文件打开,返回file对象
map(func, list) # 将列表中的每个元素作为参数传入函数func中,以列表形式返回所有执行结果
reload(module) # 重新加载之前已经导入的模块


二、控制流

if 条件表达式:
	语句
elif 条件表达式:
	语句
else:
	语句

while 条件表达式:
	语句

break # 跳出整个循环
continue # 跳出本次循环,进入下次循环
pass # 什么都不做


三、数据结构

1 列表list []

类似于C++的vector,但比vector强大。

list1.extend(list2) # 将list1与list2连接,并返回给list1
list=list1+list2 # 将list1与list2连接,并返回给list
list.insert(index, item) # 将item插入到下标为index的位置上,index位置之后的元素依次往后挪一位
list.pop(index) # 将下标index位置上的元素删除
list.reverse() # 将列表list逆序
list.append(item) # 将item插入到list末尾
list.sort() # 将列表list正序排序,也可逆序排序list.sort(reverse=True)
list.remove(item) # 删除第一个元素为item的元素,若没有该元素则返回错误
list.index(item) # 返回第一个元素为item的元素对应下标,若没有则返回错误
list.count(item) # 返回元素item出现次数


2 元组tuple ()

与列表类似,只是列表是可变的,元组是不可变的,相当于只读。


3 字典dictionary {}

字典是自动排序的。

dict.keys() # 返回由键构成的列表
dict.values() # 返回由值构成的列表
dict.items() # 返回由键值对构成的列表,常用于for key, value in dict.items():
dict.has_key(key) # 判断字典dict中是否有键key,返回布尔值
dict[key] # 返回字典中键为key对应的值
dict.get(key) # 同上
dict.pop(key) # 删除键为key的键值对
del dict[key] # 同上


4 集合set set(tuple/list)

set1 - set2 # 返回存在set1中但不存在set2中的集合
set1 | set2 # 返回要么在set1要么在set2中的集合
set1 & set2 # 返回既在set1中又在set2中的集合
set1 ^ set2 # 返回不同时在两个集合的集合


四、面向对象

Python的特点:封装、继承、多态

class Student(object): # 圆括号中是Student继承于哪个类,若没有合适的继承类就是用object
	def __init__(self, name, score): # 相当于构造方法,且第一个参数永远是self,表示创建的实例本身
		self.name = name
		self.score = score

	def print_score(self): # 类中定义的方法第一参数永远是self
		print '%s %s' %(self.name, self.score)

if __name__ == '__main__':
	s = Student('sissiy', 99) # 创建Student实例,不需要传递self参数
	s.print_score()

1 类和实例

类是创建实例的模板,实例是一个个具体的对象;

各个实例拥有独立的数据,互不影响;方法是与实例绑定的函数,与普通函数不同,方法可直接访问实例的数据;

注意:Python是动态语言,允许对实例变量绑定任何数据;


2 访问限制

若要外部不能访问内部属性,在属性的名称前面加上两个下划线__,即变成一个私有变量;

class Student(object):
	def __init__(self, name, score):
		self.__name = name
		self.__score = score
	def print_score():
		print '%s %s' %(self.__name, self.__score)

if __name__ == '__main__':
	s = Student('sissiy', 99)
	s.print_score
	# 无法使用s.name直接访问属性

注意:以双下划线为开头、双下划线为结尾的变量是特殊变量,其可直接访问;


3 继承与多态

3.1 继承

继承可以把父类的所有功能直接拿过来,子类只需新增自己特有的方法,也可以把父类的方法覆盖重写;

class Animal(object):
	def run(self):
		print 'Animal is running...'

class Dog(Animal):
	def run(self):
		print 'Dog is running...'
		
if __name__ == '__main__':
	a = Animal()
	a.run() # Animal is running
	d = Dog()
	d.run() # Dog is running

3.2 多态

调用类实例方法时尽量把变量是做父类类型,以便所有子类类型都可正常接收;

class Animal(object):
    def run(self):
        print 'Animal is running...'


class Dog(Animal):
    def run(self):
        print 'Dog is running...'

def runnew(object):
    object.run()

if __name__ == '__main__':
    runnew(Animal())
    runnew(Dog())

3.3 多重继承

通过多重继承,一个子类可同时获得多个父类的所有功能;

class Animal(object):
    pass

class Runnable(object):
    pass

class Dog(Animal, Runnable):
    pass

if __name__ == '__main__':
    d = Dog()


4 定制类

4.1 __str__

打印一个实例;

class Dog(object):
    pass

if __name__ == '__main__':
    d = Dog()
    print d

输出:

<__main__.Dog object at 0x00000000027697F0>

分析:

输出内容不好看,可重写__str__()方法,使其返回指定内容;

class Dog(object):
    def __str__(self):
        return "Dog"

if __name__ == '__main__':
    d = Dog()
    print d

输出:

Dog

4.2 __repr__

直接输入变量,而不是用print,输出内容也不好看;

>>> d = Dog()
>>> d
<__main__.Dog object at 0x00000000027097B8>

直接显示变量调用的不是__str__(),而是__repr__();

两者区别在于__str__()返回用户看到的字符串,__repr__()返回程序开发者看到的字符串,用于调试;

解决办法是再定义一个__repr__()方法,但通常__str__()和__repr__()代码一样,可如下定义:

class Dog(object):
    def __str__(self):
        return "Dog"
    __repr__ = __str__

4.3 __iter__

若想一个类用于for..in循环,必须实现__iter__()方法,该方法返回一个迭代对象,for循环则不断调用该迭代对象的next()方法拿到循环的下一个值,知道遇到StopIteration错误时退出循环;

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a,b

    def __iter__(self):
        return self # 实例本身就是迭代对象,故返回自己

    def next(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环的条件
            raise StopIteration();
        return self.a # 返回下一个值

if __name__ == '__main__':
    for n in Fib():
        print n


五、异常

1 try机制

Python内置的try...except...else...finally用以处理错误;

if __name__ == '__main__':
    try:
        print 'try...'
        r = 10 / int('a')
        print 'result:', r
    except ValueError, e: # 也可写成except ValueError as e:
        print 'ValueError:', e
    except ZeroDivisionError, e:
        print 'ZeroDivisionError:', e
    else:
        print 'no error!'
    finally:
        print 'finally...'
    print 'END'

输出:

try...
ValueError: invalid literal for int() with base 10: 'a'
finally...
END


2 抛出错误

错误也是类,不惑一个错误就是捕获该类的一个实例;

使用raise语句抛出一个错误的实例;

只有在必要时,可定义一个错误类,选择继承关系,再用raise语句抛出一个错误的实例;否则尽量使用Python内置的错误类型;

常见的错误类型和继承关系:https://docs.python.org/2/library/exceptions.html#exception-hierarchy

class FooError(StandardError):
    pass

def foo(s):
    n = int(s)
    if n==0:
        raise FooError('invalid value: %s' % s)
    return 10 / n

注意:raise语句不带参数,将把当前错误原样抛出;


3 记录错误

logging模块记录错误信息,输出到console或文件中;

3.1 简单将日志打印到屏幕

import logging
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

输出:

WARNING:root:warning message
ERROR:root:error message
CRITICAL:root:critical message

分析:

默认情况下,Python的logging模块将日志打印到标准输出中,且只显示大于等于WARNING级别的日志;

日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET;

默认日志格式为 日志级别:Logger名称:用户输出消息;

3.2 通过logging.basicConfig方法对日志的输出格式及方式进行配置

logging.basicConfig方法中参数:

filename:指定日志文件名

filemode:和file方法意义相同,指定日志文件的打开模式,如'w'或'a'

format:指定输出的格式和内容,format可以输出很多有用信息

%(levelno)s:打印日志级别的数值

%(levelname)s:打印日志级别名称

%(pathname)s:打印当前执行程序的路径,即sys.argv[0]

%(filename)s:打印当前执行程序名

%(funcName)s:打印日志的当前函数

%(lineno)d:打印日志的当前行号

%(asctime)d:打印日志的时间

%(thread)d:打印线程ID

%(threadName)d:打印线程名称

%(process)d:打印进程ID

%(message)s:打印日志信息

datefmt:指定事件格式,同time.strftime()

level:设置日志级别,默认为logging.WARNING

stream:指定将日志的输出流,可指定输出到sys.stderr、sys.stdout或文件,默认输出到sys.stderr,当stream和filename同时指定时stream被忽略

举例:

import logging

logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename='license.log',
                filemode='w')

输出license.log内容:

Thu, 04 Aug 2016 21:49:27 debug.py[line:99] DEBUG debug message
Thu, 04 Aug 2016 21:49:27 debug.py[line:100] INFO info message
Thu, 04 Aug 2016 21:49:27 debug.py[line:101] WARNING warning message
Thu, 04 Aug 2016 21:49:27 debug.py[line:102] ERROR error message
Thu, 04 Aug 2016 21:49:27 debug.py[line:103] CRITICAL critical message


六、随机数/正则表达式

1 随机数

导入模块:import random

random.random():生成一个0到1的随机浮点数[0, 1.0)

random.seed():指定随机数生成时所用算法开始的整数值,若指定值则每次生成的随机数都相同,若不指定则系统根据时间来选择随机数

random.randint(a, b):生成一个指定范围内的整数[a, b]

random.choice(sequence):从序列中获取一个随机数,可以是list, tuple, 字符串

random.sample(sequence, k):从序列中随机获取指定长度的片段

random.shuffle(list):将一个列表中元素打乱


2 正则表达式

\d —— 匹配一个数字字符

\D —— 匹配一个非数字字符

\w —— 匹配一个数字或字母

\W —— 匹配一个非数字、非字母的字符

\s —— 匹配空白符

\S —— 匹配非空白符

. —— 对前一个字符匹配任意字符

* —— 对前一个字符匹配0个或多个字符

+ —— 对前一个字符匹配1个或多个字符

? —— 对前一个字符匹配0个或1个字符

{n} —— 对前一个字符匹配n个字符

{m, n} —— 对前一个字符匹配m-n个字符

[] —— 范围,[]中的^表示取反

| —— 匹配左右表达式任意一个

^ —— 匹配行的开头

$ —— 匹配行的结束

() —— 提取分组

\ —— 转义字符


3 re模块

re模块包含所有正则表达式的功能;

3.0 import re

导入re模块;


3.1 re.compile(pattern)

编译正则表达式,返回RegexObject对象,通过该对象调用match()、search()、findall()方法;

p = re.compile(r'\d+')
result = p.match(str)
# 等价于result = re.match(r'\d+', str)


3.2 re.match(pattern, string)

从字符串的起始位置匹配一个模式,若起始位置匹配失败返回None;

其中,pattern是匹配的正则表达式,string是要匹配的字符串;

使用group(num)或groups()匹配对象函数来获取匹配表达式;

其中,group(num)提取子串,group(0)提取原始字符串,group(1)、group(2)、……表示匹配的第1、2、……个子串;groups()返回一个包含所有匹配的子串的元组;

举例:

line = "Cats are smarter than dogs"
matchObj = re.match(r'(.*) are (.*?) .*', line)
if matchObj:
	print "matchObj.group(0) : ", matchObj.group(0)
	print "matchObj.group(1) : ", matchObj.group(1)
	print "matchObj.group(2) : ", matchObj.group(2)
	print "matchObj.groups() : ", matchObj.groups()

输出:

matchObj.group(0) :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter
matchObj.groups() :  ('Cats', 'smarter')


3.3 re.search(pattern, string)

匹配并提取第一个匹配的对象,若匹配失败返回None;

使用group(num)或groups()匹配对象函数来匹配表达式;

举例:

line = "Cats are smarter than dogs";
searchObj = re.search(r'(.*) are (.*?) .*', line)
if searchObj:
	print "searchObj.group(0) : ", searchObj.group(0)
	print "searchObj.group(1) : ", searchObj.group(1)
	print "searchObj.group(2) : ", searchObj.group(2)
	print "searchObj.groups() : ", searchObj.groups()

输出:

searchObj.group(0) :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter
searchObj.groups() :  ('Cats', 'smarter')


3.4 re.findall()

匹配所有匹配的对象,返回类型是list;

使用下标对其进行遍历,从0开始;

举例:

str = '12a32bc43jf'
a = re.findall(r'\d+', str)
print a
print a[0]

输出:

['12', '32', '43']
12


你可能感兴趣的:(项目)