准备环境

Mac下安装

sudo pip3 install ipython
ipython

基本语法

基本运算

7/3
7//3 #取整
100/(1+0.1)**2 #**用来计算幂函数 pow((1+0.1),2)
17%4 #计算余数

条件分支与循环控制

if

if 表达式 :
    ...
else :
    ...

if 表达式 :
    ...
elif 表达式 :
    ...
else :
    ...

if-else条件分支语句，系统会判断if后边的表达式是否成立，如果值为True则执行冒号下边的代码片，否则判断随后elseif的表达式。

三元运算符

result = x if x<5 else 5

while

while i<=x :
  print(i)
  i += 1

for

for循环的作用是可以循环输出集合/数组中的每一个元素，类似于Java中的ForEach语句.
arr = [1, 2, 3, 4, 5]
for j in arr :
print(j)

注意不是arr[j]

使用range循环

内置range函数的作用是记录范围，通常和for循环结合使用

result = range(0, 10 ,1) #range函数获得一个0-10的范围集合，以1为步进数（即每次+1）
for item in result: #循环输出每一个元素
    print(item)

模拟Java的标准for循环

arr = [1, 2, 3, 4, 5]
for i in range(0, len(arr), 1) :
   print(arr[i])

函数

基本语法

def hello(): #函数的声明
    '这是我的第一个函数' #定义函数文档
    print("hello world")

print(hello.__doc__) #打印函数文档，双下划线
help(hello) #可以通过help函数打印函数文档

有参函数

def info(name, age): #定义有参函数
    return "这是有参函数：I'm %s %s years old" %(name, age) #返回字符串

def info1(name="HanMeimei", age=36):  #参数可以设置默认值
    print("这是默认值参数函数：I'm %s %s years old" %(name, age))

可变参数函数

def myFunction1(*params): #定义可变参数的函数
    print("参数的长度是：%s" %len(params))
    for item in params:
        print(item)
myFunction1("hello", "world") #函数的调用

匿名函数

使用lambda表达式

g = lambda x, y: x + y

等同下面的

def f(a, b):
    return a + b

字符串

常用操作

str1 = "hello world"
str2 = str1[3:5] #从str1的第4位截取到底6位，不包含底6位
print(str1[6:]) #截取第七个字符到结尾
print(str1[:-3]) #截取从头开始到倒数第三个字符之前
print(str1[2]) #截取第三个字符

result1 = str1.lower(); #将str1转换成小写
result2 = str1.upper(); #将str1转换成大写

str1 = "hello world"
str1=str1.capitalize(); #首字母大写
print(str1)
Hello world

str1 = "  HelloWorld  "
result1 = str1.lstrip(); #去str1的左侧空格
result2 = str1.rstrip(); #去str1的右侧空格
result3 = str1.strip(); #去str1的左右侧空格

str1 = "HelloWorld"
len(s1) #求字符串长度
result = str1.count('o') #获取次数的函数

str1 = "HelloWorld"
result1 = str1.startswith('ld') #判断str1是否是以字符串ld开头，返回值是布尔型
result2 = str1.endswith('ld') #判断str1是否是以字符串ld结尾，返回值是布尔型

str1 = "HelloWorld"
result1 = str1.find('o') #从str1左侧查找o，如果找到返回位置索引，找不到返回-1
result1 = s1.find('o',7,10)
result2 = str1.rfind('o') #从str1右侧查找o，如果找到返回位置索引，找不到返回-1

str1 = "aaa,bbb,ccc"
result = str1.replace(",", "#") #将str1中所有的逗号替换成井号
print("替换后的字符串是：%s" %result)

str1 = "aaa,bbb,ccc"
result = str1.split(",") #将字符串按指定字符转换成字符串数组
print(result)


list = ['hello','world']
str = '-'
str.join(list) #list转换为str
'hello-world'

str1 = "{a} love {b}".format(a="LiLei", b="HanMeimei")
str2 = "%s love %s" %("LiLei", "HanMeimei")

s1 = 'hello'
s2 = 'world'
s3 = s1 + s2  #字符串连接


s1 = 'hello'
max(s1) #求字符串s1中最大字符

s1 = 'hello'
s1[::-1] #字符串翻转
'olleh'

l = list(s1)#字符串转列表
l.reverse()  #列表反转（reverse直接对列表进行了修改）
result = "".join(l)#使用列表的reverse方法


s1  = 'hello'
s1.isdigit()//检测字符串时候只由数字组成
s1.isalpha() ———— 检测字符串是否只由字母组成

str_test = "{'a': 1, 'b': 2}"
dict_test = eval(str_test) #字符串转换为字典
str_test2 = str(dict_test)

常用数据结构

元组tuple

小括号，元组中的元素的值不可以修改，因此比列表安全。

z = ("a", "b", "c", "d", "e")
z?
Type:        tuple
print(z)
('a', 'b', 'c', 'd', 'e')

基本操作

读取z中的元素，与list类似
print(z[0])

列表list

中括号,有点像java中的list,list中可以放不同类型的元素，在python中数组也是用list进行表达。
y = [“A”, “B”, “C”, “a”, “b”, “c”]
intArr = [1, 4, 2, 5, 3, 7, 9, 0] #整型数组
strArr = [“北京”, “上海”, “杭州”, “深圳”] #字符串数组
mixArr = [1, 3.44, “hello”, [1, 2, 3]] #混合数组
emptyArr = [] #空数组

基本操作

读取

y[-1]
y[0]
y[0: 3]

查找

y.index(“a”)

插入

最后面插入新元素

y.append(5)
y.append([“d”, “e”])

在指定位置插入新元素
y.insert(3, “new”)

合并

x = [“A”, “B”, “C”]
y = [“A”, “B”, “D”]
print(x+y)
[‘A’, ‘B’, ‘C’, ‘A’, ‘B’, ‘D’]

删除

y.remove(“B”)

分片

截取数组中的一个片段，并生成一个新的数组

x=[0,1,2,3,4,5,6,7,8,9]

从开始位置到结束位置获取数组中的元素集合

x2 = x[1 : 3]
print(x2)
[1, 2]

是否存在某元素

result = "上海" in strArr
print(result);
True
result = "ShangHai" not in strArr
print(result);

获取指定元素的个数

strArr.append("上海")
strArr.append("上海")
result = strArr.count("上海");
print(result);
3

排序

intArr.sort()
print(result)
intArr.reverse()
print(intArr)

获取最大值/最小值

result = max(intArr)
print(result)
result = min(temp)
result = sum(temp)

综合示列

arr = [4, 2, 5, 3, 45, 232, 98, 1, 0, 6, 89, 43] #创建一个整型数组

for i in range(0, len(arr), 1): #for循环初始值是0，范围是数组的长度
    if arr[i] % 2 == 0: #找到偶数的元素
        arr[i] += 1 #让元素+1
arr.sort() #元素从小到大排序
cnt = arr.count(1) #获取指定元素的个数

print("值=1的元素个数：%s" %cnt)
print(arr)

Set

大括号,如果需要去掉重复，这时需要Set

y = {'x', 'z', 'y'}
y?
Type:        set

使用列表进行构建

a=["x","x","y","z"]
b=set(a)
print(b)

集合操作

x1 = set([“A”, “B”, “C”])
y1 = set([“A”, “B”, “D”])

交集

print(x1&y1)
{‘A’, ‘B’}

并集

print(x1|y1)
{‘C’, ‘A’, ‘B’, ‘D’}

差集

print(x1-y1)
{‘C’}

字典dict

使用大括号{}表示

x = {"name": "zhangshang", "age": 33, "address": "xxxx"}
print(x["name"])

获取

print(x[‘name’])

如果取一个不在的如果使用x[‘g],会出现异常，可以使用下面的get方法，返回None
print(x.get(‘g’))
print(x.get(‘g’,’没有这个值’))

方法

print(x.keys())
dict_keys([‘name’, ‘age’, ‘address’])

print(len(x))

几个常用的内置函数

range

range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型
l = range(6)
list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表
list(range(10))

语法

range(stop)
range(start, stop[, step])

举例：

>>>range(5)
range(0, 5)
>>> for i in range(5):
...     print(i)
... 
0
1
2
3
4
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(0))
[]
>>>

map

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

map(lambda x: x + 1, l)

内置的map函数有两个参数，第一个是一个函数；第二个是一个可遍历的对象

def f1(x):
    return x*x

list(map(f1,[1,2,3,4]))

filter

filter函数会对指定序列执行过滤操作。接受一个参数，返回布尔值True或False。

list(filter(lambda x: x % 2 == 0,  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))

reduce

reduce函数，reduce函数会对参数序列中元素进行累积。
reduce函数的定义：reduce(function, sequence[, initial]) -> value

在Python 3里,reduce()函数已经被从全局名字空间里移除了,它现在被放置在fucntools模块里用的话要先引入

from functools import reduce
l = range(6)
f = lambda accumValue, newValue: accumValue + newValue
reduce(f, l, 0)

第1个参数是相加函数，第2个参数是需要求和的列表“l”，第3个（可选）参数为初始值0。

第一次调用function时，如果提供initial参数，会以sequence中的第一个元素和initial作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function

面向对象和模块化

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。

模块让你能够有逻辑地组织你的python代码段；把相关的代码分配到一个模块里能让你的代码更好用，更易懂。模块能定义函数，类和变量，模块里也能包含可执行的代码。

import语法

通过import导入整个模块

语法：

import module1[, module2[,… moduleN]

例如

import pandas  as pd  #pd为别名

From…import导入指定模块的部分属性或者模糊导入

语法：

from modname import name1

例如
from mini_project.components.Person import sayHello
这样就可以直接使用sayHello

导入模块的所有功能
from pandas import *

搜索路径

当导入一个模块后，python解析器对模块文件的搜索顺序是：
当前目录—-shell变量PYTHONPATH下的每个目录———-python模块路径目录
模块的搜索路径存储在system模块的sys.path变量中，包括当前目录，pythonpath和安装过程决定的默认目录。

通过下面可以参看系统搜索路径

import sys
print(sys.path)     #默认搜索路径

如果程序动态添加可以使用

sys.path.append("/media")   #添加模块路径到搜索路径中

包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。使用包可以很好的组织Python的工程结构，一个包就是一个模块。

简单来说，Python的库其实就是一个包含init.py文件夹，但该文件夹下必须存在 init.py 文件用来指明这是一个包，其用来定义库属性和方法，该文件的内容可以为空。

一个简单工程参考目录如下：

├── __init__.py
├── __pycache__
│   └── __init__.cpython-36.pyc
├── components
│   ├── Person.py
│   ├── __init__.py
│   └── __pycache__
│       ├── Person.cpython-36.pyc
│       └── __init__.cpython-36.pyc
└── tests
    ├── __init__.py
    └── test_person.py    

类

创建Person.py

# -*- coding: UTF-8 -*-
#-------------------------------------
# file:Person.py


class Person:
    #属性--变量
    __sex = "男"  #私有变量，只需要在变量前加两个下划线
    name = None
    age = None

    #方法--函数
    def sayHello(self, friendName):
        print(
            "Hello %s I'm %s %s years old" % (friendName, self.name, self.age))

    #构造函数
    def __init__(self, name, age):
        self.name = name
        self.age = age

通过class关键字定义类名，要求类名的首字母大写，定义成员方法时，要求传递self参数（相当于Java中的this关键字）；
Python中定义构造函数，要求构造函数的名称是init
Python 没有严格区分公共 / 外部属性和私有 / 内部属性，但是按照惯例，前面带有下划线表示私有属性或方法。

创建测试文件test_person.py

# -*- coding: UTF-8 -*-
"""
test_person.py此脚本用于测试person
"""

from os import sys, path


if __name__ == "__main__":
    # 得到mini_project所在的绝对路径
    packagePath = path.dirname(path.dirname(path.dirname(path.abspath(__file__))))
    # 将mini_project所在路径，加到系统路径里。这样就可以将mini_project作为库使用了
    sys.path.append(packagePath)
    import mini_project.components.Person as p
    #import 面向对象.类对象.Person as p
    person = p.Person("张三", 28)
    person.sayHello("xxxxx")

    # print(p.__sex) #无法访问，因为__sex变量是私有的
    print(person._Person__sex) #python是伪私有，如果想访问私有变量可以通过    p._Person__sex，即：对象名._类名__变量名

如果一个模块中的name的属性值为main,那么这个模块就是主模块。

直接运行python3 test_person.py

ipython使用技巧

一些技巧

使用通配符

In [10]: *Warning?
In [10]: str.*find*?

标准的 Python shell 仅仅包括一个用于获取以前的输出的简单快捷键。

In [9]: print(_)

如果想一次性获取此前所有的输入历史，%history 魔法命令会非常有用

In [16]: %history -n 1-4

! 符号作为前缀在 IPython 中执行任何命令行命令

In [1]: !ls

IPython shell中的快捷键

Ctrl + a

将光标移到本行的开始处

Ctrl + e

将光标移到本行的结尾处

Ctrl + b（或左箭头键）

将光标回退一个字符

Ctrl + f（或右箭头键）

将光标前进一个字符

Ctrl + p（或向上箭头）

获取前一个历史命令

Ctrl + n（或向下箭头）

获取后一个历史命令

Ctrl + l

清除终端屏幕的内容

Ctrl + c

中断当前的 Python 命令

Ctrl + d

退出 IPython 会话

IPython增强命令

粘贴代码块：%paste和%cpaste

执行外部代码：%run

计算代码运行时间：%timeit

参考网站

• Python语法
• python3之模块