为什么选择 Python：核心特性与优势解析

为什么选择 Python：核心特性与优势解析 | 极客日志

def pig_latin(text):
    ''' Takes in a sequence of words and converts it to (imperfect) pig latin. '''
    word_list = text.split(' ')
    output_list = []

    for word in word_list:
        word = word.lower()

        if word.isalpha():
            first_char = word[0]

            if first_char in 'aeiou':
                word = word + 'ay'
            else:
                word = word[1:] + first_char + 'yay'

            output_list.append(word)

    pygged = ' '.join(output_list)
    return pygged

test1 = pig_latin("let us see if this works")
print(test1)

# Create a box (really, a 'list') with 5 things
my_box_of_things = ['Davenport', 'kettle drum', 'swallow-tail coat', 'table cloth', 'patent leather shoes']
print(my_box_of_things)

['Davenport', 'kettle drum', 'swallow-tail coat', 'table cloth', 'patent leather shoes']

# Add a few more things
my_box_of_things += ['bathing suit', 'bowling ball', 'clarinet', 'ring']

# Maybe add one last thing
my_box_of_things.append('radio that only needs a fuse')

# Let's see what we have...
print(my_box_of_things)

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadFile {
    public static void main(String[] args) throws IOException{
        String fileContents = readEntireFile("./foo.txt");
    }

    private static String readEntireFile(String filename) throws IOException {
        FileReader in = new FileReader(filename);
        StringBuilder contents = new StringBuilder();
        char[] buffer = new char[4096];
        int read = 0;
        do {
            contents.append(buffer, 0, read);
            read = in.read(buffer);
        } while (read >= 0);
        return contents.toString();
    }
}

# Read the contents of "hello_world.txt"
text = open("hello_world.txt").read()

[
  {
    "_id": "59ad8f86450c9ec2a4760fae",
    "name": "Dyer Kirby",
    "registered": "2016-11-28T03:41:29 +08:00",
    "latitude": -67.170365,
    "longitude": 130.932548,
    "favoriteFruit": "durian"
  },
  {
    "_id": "59ad8f8670df8b164021818d",
    "name": "Kelly Dean",
    "registered": "2016-12-01T09:39:35 +08:00",
    "latitude": -82.227537,
    "longitude": -175.053135,
    "favoriteFruit": "durian"
  }
]

import json
data = json.loads(data_string)
print(data)

# Create a list of random floats
import random
my_list = [random.random() for i in range(10000)]

# Python's built-in sum() function is pretty fast
%timeit sum(my_list)

def ill_write_my_own_sum_thank_you_very_much(l):
    s = 0
    for elem in my_list:
        s += elem
    return s

%timeit ill_write_my_own_sum_thank_you_very_much(my_list)

import numpy as np

my_arr = np.array(my_list)

%timeit np.sum(my_arr)

# Jupyter extension that allows us to run Cython cell magics
%load_ext Cython

The Cython extension is already loaded. To reload it, use:
  %reload_ext Cython

%%cython
def ill_write_my_own_cython_sum_thank_you_very_much(arr):
    cdef int N = len(arr)
    cdef float x = arr[0]
    cdef int i
    for i in range(1, N):
        x += arr[i]
    return x

%timeit ill_write_my_own_cython_sum_thank_you_very_much(my_list)

import numpy as np

def multiply_randomly_naive(l):
    n = l.shape[0]
    result = np.zeros(shape=n)
    for i in range(n):
        ind = np.random.randint(0, n)
        result[i] = l[i] * l[ind]
    return np.sum(result)

%timeit multiply_randomly_naive(my_arr)

def multiply_randomly_vectorized(l):
    n = len(l)
    inds = np.random.randint(0, n, size=n)
    result = l * l[inds]
    return np.sum(result)

%timeit multiply_randomly_vectorized(my_arr)

import numpy as np
from numba import jit

@jit
def multiply_randomly_naive_jit(l):
    n = l.shape[0]
    result = np.zeros(shape=n)
    for i in range(n):
        ind = np.random.randint(0, n)
        result[i] = l[i] * l[ind]
    return np.sum(result)

%timeit multiply_randomly_naive_jit(my_arr)

def double(x):
    return x*2

# Lists all object attributes
dir(double)

class Brain(object):

    def __init__(self, owner, age, status):
        self.owner = owner
        self.age = age
        self.status = status

    def __getattr__(self, attr):
        if attr.startswith('get_'):
            attr_name = attr.split('_')[1]
            if hasattr(self, attr_name):
                return lambda: getattr(self, attr_name)
        raise AttributeError

# Create a new Brain instance
brain = Brain(owner="Sue", age="62", status="hanging out in a jar")

print(brain.owner)
# Output: Sue

print(brain.gender)
# Raises AttributeError

print(brain.get_owner())

from nibabel import Nifti1Image
from nilearn.image import new_img_like
from nilearn.plotting import plot_stat_map
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

class LazyMask(Nifti1Image):
    ''' A wrapper for the Nifti1Image class that overloads the & and | operators
    to do logical conjunction and disjunction on the image data. '''

    def __and__(self, other):
        if self.shape != other.shape:
            raise ValueError("Mismatch in image dimensions: %s vs. %s" % (self.shape, other.shape))
        data = np.logical_and(self.get_data(), other.get_data())
        return new_img_like(self, data, self.affine)

    def __or__(self, other):
        if self.shape != other.shape:
            raise ValueError("Mismatch in image dimensions: %s vs. %s" % (self.shape, other.shape))
        data = np.logical_or(self.get_data(), other.get_data())
        return new_img_like(self, data, self.affine)

img1 = LazyMask.load('image1.nii.gz')
img2 = LazyMask.load('image2.nii.gz')
result = img1 & img2

为什么选择 Python：核心特性与优势解析

为什么选择 Python

概述

Python（相对来说）易于学习

Python 是一种高级语言

Python 是一种通用语言

标准库

JSON，简单的方法

优异的外部支持

Python 是一种（相对）快速的语言

不要重复做功

需要更快的速度？

使用 Cython 编写 C 代码

使用 NUMBA 进行清理

Python 是天生面向对象的

魔术方法

Python 社区

结论

更多推荐文章

相关免费在线工具

为什么选择 Python：核心特性与优势解析

为什么选择 Python

概述

Python（相对来说）易于学习

Python 是一种高级语言

Python 是一种通用语言

标准库

JSON，简单的方法

优异的外部支持

Python 是一种（相对）快速的语言

不要重复做功

需要更快的速度？

使用 Cython 编写 C 代码

使用 NUMBA 进行清理

Python 是天生面向对象的

魔术方法

Python 社区

结论

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具