1小时玩转python

Python介绍
如果你问我没有编程基础，相学习一门语言，我一定会首推给你Python
类似伪代码的书写方式，让你能够集中精力去解决问题，而不是花费大量的时间在开发和debug上
同时得益于Numpy/Scipy这样的科学计算库，使得其有非常高效和简易的科学计算能力。
而活跃的社区提供的各种可视化的库，也使得数据挖掘的全过程(数据采集，数据清洗，数据处理，建模，可视化)可以非常流畅地完成。

这个教程里面的内容包括：

基本Python语法: 基本数据类型 (Containers, Lists, Dictionaries, Sets, Tuples), 函数, 类
Numpy: Arrays/数组, Array indexing/数组取值, Datatypes, Array math, Broadcasting
Matplotlib: 绘图，子图，图片读取
IPython: Ipython交互式编程界面介绍
基本python语法
Python确实经常被人像伪代码，下面是一个快排程序，你可以感受一下:

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = len(arr)/ 2
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

a=[9,8,5,4,7,3,5,1,9]
result=quicksort(a)
print(result)

基本数据类型
数值型
整型和浮点型以及基本的运算大家应该都知道：

x = 4.0
print(x, type(x))

print(x + 1)   # 加;
print(x - 1)   # 减;
print(x * 2)   # 乘;
print(x ** 2)  # 指数;x += 1

x += 1
print(x) # 自加
x *= 2
print(x) # 自乘

y = 2.5
print(type(y)) # 输出类型
print(y, y + 1, y * 2, y ** 2) # 连续输出

输出：
4.0 <class 'float'>
5.0
3.0
8.0
16.0
5.0
10.0
<class 'float'>
2.5 3.5 5.0 6.25

不过需要提醒一句，用习惯C++和Java的同学，Python真的没有(x++)和(x–)这俩操作
布尔型
用于指定真假的类型，布尔型，包含真（True）和假（False）:

t, f = True, False
print(type(t)) # Prints "<type 'bool'>"

# 看看逻辑与或非这些操作
print(t and f) # Logical AND;
print(t or f)  # Logical OR;
print(not t)   # Logical NOT;
print(t != f)  # Logical XOR;

输出：
<class 'bool'>
False
True
False
True

字符串型

hello = 'hello'   # 实在想不出的时候就用hello world
world = "world"
print(hello, len(hello)) # 字符串长度

hw = hello + ' ' + world  # 字符串拼接
print(hw)

hw12 = '%s %s %d' % (hello, world, 12)  # 类似sprintf的格式化输出
print(hw12)  # prints "hello world 12"

输出：
hello 5
hello world
hello world 12

#我能说什么，你面试的时候面试官最爱让你写的字符串操作，都是它自带的:

s = "hello"
print(s.capitalize())  # 首字母大写
print(s.upper())       # 全大写
print(s.rjust(7))      # 靠右对齐
print(s.center(7))     # 居中输出
print(s.replace('l', '(ell)'))  # 字符串替换
print('  world '.strip())  # 去掉两侧空白

输出：
Hello
HELLO
  hello
 hello 
he(ell)(ell)o
world

容器
内置的容器用得非常非常多，包括: lists, dictionaries, sets, and tuples.
Lists/列表
和你学数据结构里面数组长得一样的容器，但是操作可多多了:

xs = [3, 1, 2, 5]   # 建一个列表
print(xs, xs[2])
print(xs[-1])     # 用-1表示最后一个元素，输出来

xs[2] = 'Hanxiaoyang'    # 有意思的是，Python的list居然可以有不同类型的元素
print(xs)

xs.append('happy') # 可以用append在尾部添加元素
xs += ['happy']
print(xs)

x = xs.pop()     # 也可以把最后一个元素“弹射”出来
print(x, xs)

输出：
[3, 1, 2, 5] 2
5
[3, 1, 'Hanxiaoyang', 5]
[3, 1, 'Hanxiaoyang', 5, 'happy', 'happy']
happy [3, 1, 'Hanxiaoyang', 5, 'happy']

列表切片
这是大家最爱python list的原因之一，取东西太方便啦:

nums = [x for x in  range(5) ]  # 0-4
print(nums)        # 输出 "[0, 1, 2, 3, 4]"
print(nums[2:4])   # 下标2到4(不包括)的元素，注意下标从0开始
print(nums[2:])     # 下标2到结尾的元素; prints "[2, 3, 4]"
print(nums[:2])     # 直到下标2的元素; prints "[0, 1]"
print(nums[:])      # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]"
print(nums[:-1])    # 直到倒数第一个元素; prints ["0, 1, 2, 3]"
nums[2:4] = [8, 9] # 也可以直接这么赋值
print(nums)         # Prints "[0, 1, 8, 8, 4]"

输出：
[0, 1, 2, 3, 4]
[2, 3]
[2, 3, 4]
[0, 1]
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
[0, 1, 8, 9, 4]

循环
可以对list立面的元素做一个循环:

animals = ['喵星人', '汪星人', '火星人']
for animal in animals:
    print(animal)

输出：
喵星人
汪星人
火星人

又要输出元素，又要输出下标怎么办，用 *enumerate *函数:

animals = ['喵星人', '汪星人', '火星人']
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))

输出：
#1: 喵星人
#2: 汪星人
#3: 火星人

List comprehensions:
如果对list里面的元素都做一样的操作，然后生成一个list，用它最快了，这绝对会成为你最爱的python操作之一:

# 求一个list里面的元素的平方，然后输出，很out的for循环写法
nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
    squares.append(x ** 2)
print（squares）

输出：
[0, 1, 4, 9, 16]

用list comprehension可以这么写:

nums = [0, 1, 2, 3, 4]
# 对每个x完成一个操作以后返回来，组成新的list
squares = [x ** 2 for x in nums]
print(squares)

输出：
[0, 1, 4, 9, 16]

你甚至可以加条件，去筛出你想要的元素，去做你想要的操作:

nums = [0, 1, 2, 3, 4]
# 把所有的偶数取出来，平方后返回
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(even_squares)

输出：
[0, 4, 16]

字典
存储键值对(key => value)的数据结构, 类似Java中的Map，这真的是我使用频度相当高的数据结构:

d={}
d = {'cat': 'cute', 'dog': 'furry'}  # 建立字典
print(d['cat'])       # 根据key取value
print('cat' in d)     #
d['fish'] = 'wet'    # 设定键值对
print(d['fish'])      # 这时候肯定是输出修改后的内容
print(d)
print(d.get('monkey', '1'))  # 可以默认输出'N/A'（取不到key对应的value值的时候）
print(d.get('fish', '1'))
del d['fish']        # 删除字典中的键值对
print(d.get('fish', 'N/A')) # 这会儿就没有了

输出：
cute
True
wet
{'cat': 'cute', 'dog': 'furry', 'fish': 'wet'}
1
wet
N/A

你可以这样循环python字典取出你想要的内容:

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal in d:
    legs = d[animal]
    print('A %s has %d legs' % (animal, legs))

输出：
A person has 2 legs
A cat has 4 legs
A spider has 8 legs

用iteritems函数可以同时取出键值对:

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal, legs in d.items():
    print('A %s has %d legs' % (animal, legs))

输出：
A person has 2 legs
A cat has 4 legs
A spider has 8 legs

#Dictionary comprehensions: 和list comprehension有点像啦，但是生成的是字典:

nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print(even_num_to_square)

输出：
{0: 0, 2: 4, 4: 16}

Sets
你可以理解成没有相同元素的列表（当然，显然和list是不同的）:

animals = {'cat', 'dog'}
print('cat' in animals)   # Check if an element is in a set; prints "True"
print('fish' in animals)  # prints "False"

animals.add('fish')      # 添加元素
print('fish' in animals)
print(len(animals))       # 元素个数

animals.add('cat')       # 如果元素已经在set里了，操作不会怎么样
print(len(animals))
animals.remove('cat')    # 删除一个元素
print(len(animals))

animals = {'cat', 'dog', 'fish'}
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))
# Prints "#1: fish", "#2: dog", "#3: cat"

# Set comprehensions: 熟悉的感觉:
from math import sqrt
print({int(sqrt(x)) for x in range(30)})

输出：
True
False
True
3
3
2
#1: dog
#2: fish
#3: cat
{0, 1, 2, 3, 4, 5}

元组
和list很像，但是可以作为字典的key或者set的元素出现，但是一整个list不可以作为字典的key或者set的元素的:

d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys
t = (5, 6)
# Create a tuple
print(d)
print(type(t))
print(d[t])
print(d[(1, 2)])

输出：
{(0, 1): 0, (1, 2): 1, (2, 3): 2, (3, 4): 3, (4, 5): 4, (5, 6): 5, (6, 7): 6, (7, 8): 7, (8, 9): 8, (9, 10): 9}
<class 'tuple'>
5
1

函数
用 def 就可以定义一个函数，就像下面这样:

def sign(x):
    if x > 0:
        return 'positive'
    elif x < 0:
        return 'negative'
    else:
        return 'zero'

for x in [-1, 0, 1]:
    print(sign(x))
 
 输出：
negative
zero
positive

函数名字后面接的括号里，可以有多个参数，你自己可以试试:

def hello(name, loud=False):
    if loud:
        print('HELLO, %s' % name.upper())
    else:
        print('Hello, %s!' % name)

hello('Bob')
hello('Fred', loud=True)

输出：
Hello, Bob!
HELLO, FRED

类
Python的类，怎么说呢，比较简单粗暴:

class Greeter:

    # 构造函数
    def __init__(self, name):
        self.name = name  # Create an instance variable

    # 类的成员函数
    def greet(self, loud=False):
        if loud:
            print('HELLO, %s!' % self.name.upper())
        else:
            print('Hello, %s' % self.name)

g = Greeter('Fred')  # 构造一个类
g.greet()            # 调用函数; prints "Hello, Fred"
g.greet(loud=True)   # 调用函数; prints "HELLO, FRED!"

输出：
Hello, Fred
HELLO, FRED!

向林
2020年2月13日于重庆城口
好好学习，天天向上,终有所获