python 基礎python入門python基本的資料類型 運算符深淺拷貝函數（function）Lambda表達式python3内置函數

python指定字元編碼（utf8）：

#！/usr/bin/env python

# _*_ coding:utf-8 _*_

# -*- coding:utf-8 -*-

# coding:utf-8

字元串：用單引号或者雙引号包起來

數字

bool

if - elif - else

while

while - else

break

continue

for

for - else

enumrate：周遊序列中的元素及他們的下标。

character=["a","b","c","d"]

for key, value in enumrate(character):

  print(key, value)

range和xrange

range在Python2.7中，會把所有的序列都輸出出來，沒一個序列都在記憶體中占用一點空間

xrang不會一次性把序列全部都存放在記憶體中，而是用到for循環進行疊代的時候才會一個一個的存到記憶體中，相當于Python3.5中的range。

range在python3.5中就不會一次性的占用那麼多空間，他會我需要用到這個序列的時候然後再記憶體中開辟一塊空間給這個序列，不是一次性分完，相當于Python2.7.11中的xrange.

條件判斷

if 

if ... and  ... :

if ... or ... :

數字、字元串、清單、字典、元組

所有的資料類型所具備的方法都存在相對應的類裡面，當建立一個類型的對象時，該對象所具備的功能都儲存在相應的類中。

對象是基于類的，也就是說如果我定義一個資料類型是字元串類型的，那麼類型字元串就是<code>類</code>，二定義的變量就是對象，對象所擁有的功能都是從類裡面去拿的。

 不可變類型(數字、字元串、元組、不可變集合)：不可變的類型是不支援修改原資料的，每次對不可變類型的資料進行修改時都是重新建立一個對象然後指派給變量。

 可變類型(清單、字典、可變集合)：可變類型是支援修改源資料，而不用重新建立新的對象

數字類型的長度限制：2.7中分int和long範圍不一樣，3.x中不區分可以儲存任意數字。

數字類型的方法：

 bit_length：該數字占用的最少位數

 conjugate：該複數的共轭複數

 imag：複數的虛數

 整數比浮點數簡單、浮點數比複數簡單。

集合的元素是不允許重複、不可變且無序的集合

建立集合：s = set([11,22,33])   s = {11,22,33}

集合的方法：

add（添加）、clear（清除）、difference（set1中有，set2中沒有的）、difference_update（set1中有，set2中沒有的，并且指派給set1）、

discard（移除指定元素，不存在不報錯）、remove（移除指定元素，不存在報錯）、

intersection（交集）、intersection_update、isdisjoint（是否有交集）、issubset、issuperset、

pop（移除一個元素，顯示移除的元素）、symmetric_difference（對稱交集，把兩個都沒有的元素存在一起）、symmetric_difference_update（對稱交集，儲存到set1中）、

union（并集，有重複的隻存一個）、update（把set1中的元素update到set2中）

字元方法：自行help

str類型和bytes：3.x中輸出是一個字元，2.x輸出是按照直接輸出。

 索引就是位置、轉義符、字元串中的+、切片

切片操作：

切片符

說明

[:]

提取從開頭到結尾的整個字元串

[start:]

從start到結尾的字元串

[:end]

從開頭提取到end - 1

[start:end]

從start提取到end - 1

[start : end : setp]

從start提取到end-1，每setp個字元提取一個

 name_list=['python', 'php', java']

name_list=(['python','php','java'])

清單方法：自行help

dic = {"k1":"123","k2":"456"}

dic = dict({"k1":"123","k2":"456"})

 字典方法：自行help

 元組(tuple)和清單的為唯一差別就是清單可以更改，元組不可以更改，其他功能與清單一樣

 ages=(11,22,33,44,55)

ages=tuple((11,22,33,44,55))

元組的元素本身是不可修改的，但是如果元組的元素是個清單或者字典那麼就可以被修改

+、-、*、/、%、**、//（整除餘，傳回商的整數部分）

==、!=、&lt;&gt;、&gt;、&lt;、&gt;=、&gt;=

 =、+=、-=、*=、/=、%=、**=、//=

and、or、not

in、not in

variable=value1 if condition else value2

 2.x版本使用ascii字元集，3.x使用utf8字元集

數字和字元串對于深淺拷貝沒有任何意義，他們的值永遠指向同一記憶體位址。

字典、元祖、清單深淺拷貝時，記憶體位址的變化不同。 

淺拷貝：在記憶體中隻額外建立第一層資料。建立第一個變量和第二個變量，他們的記憶體位址不同，但是兩個變量裡面的值的記憶體位址相同。

深拷貝：在記憶體中将所有的資料重新建立一份（排除最後一層，即：python内部對字元串和數字的優化）。直接把第一個變量的内容直接拷貝給第二個變量，是以兩個變量的記憶體位址不同，并且兩個變量的值的記憶體位址也不同。

函數的寫法、函數的傳回值、函數的預設值、函數的動态參數、

動态參數可以接受使用者輸入的任何參數，包括字典、清單、元組等資料類型。

nonlocal：修改嵌套作用域中的變量，類似于golbal。隻需要在嵌套函數中聲明變量名即可，但是這個變量名是必須已經存在的否則就會報錯，如果要修改的變量在作用域中查找不到，那麼不會繼續到全局或内置作用域中查找。

用lambda關鍵字建立的匿名函數，可以用于任何需要函數對象的地方，在文法上，被局限于隻能有一個單獨的表達式。

func=lambda x,y : x+y

func(1,2)

等效于下面函數

def func(x,y):

  return x+y

abs(x)

all(iterable)

any(iterable)

ascii(object)

bin(x)

bool([x])

callable(object)

chr(i)

classmethod(function)

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

complex([real[, imag]])delattr(object, name)

dict(**kwarg)

dir([object])

divmod(a, b)

enumerate(iterable, start=0)

eval(expression, globals=None, locals=None)

exec(object[, globals[, locals]])

filter(function, iterable)

float([x])

format(value[, format_spec])

frozenset([iterable])

getattr(object, name[, default])

globals()

hasattr(object, name)

hash(object)

help([object])

hex(x)

id(object)

input([prompt])

int(x, base=10)

isinstance(object, classinfo)

issubclass(class, classinfo)

iter(object[, sentinel])

len(s)

list([iterable])

locals()

map(function, iterable, …)

max(iterable, *[, key, default])

memoryview(obj)

min(iterable, *[, key, default])

next(iterator[, default])

oct(x)

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

ord(c)

pow(x, y[, z])

property(fget=None, fset=None, fdel=None, doc=None)

range(start, stop[, step])

repr(object)

reversed(seq)

round(number[, ndigits])

set([iterable])

setattr(object, name, value)

slice(start, stop[, step])

sorted(iterable[, key][, reverse])

staticmethod(function)

str(object=b’’, encoding=’utf-8’, errors=’strict’)

sum(iterable[, start])

super([type[, object-or-type]])

tuple([iterable])

type(object)

vars([object])

zip(*iterables)

import(name, globals=None, locals=None, fromlist=(), level=0)

本文轉自ting2junshui51CTO部落格，原文連結：http://blog.51cto.com/ting2junshui/1893747 ，如需轉載請自行聯系原作者