一.變數

1 什麼是變數之宣告變數

#變數名=變數值
age=18
gender1='male' 
gender2='female'

2 為什麼要有變數

變數作用：“變”=>變化，“量”=>計量/儲存狀態
程式的執行本質是一系列狀態的變化，變數的目的就是用來儲存狀態，變數值的變化就構成了程式執行的不同結果。
例如：CS槍戰，一個人的生命可以表示為life＝active表示存活，當滿足某種條件後修改變數life＝inactive表示死亡。
3 變數值之型別與物件
程式中需要處理的狀態很多，於是有了不同型別的變數值，x='egon',變數值'egon'存放與記憶體中，繫結一個名字x，變數值即
 
我們要儲存的資料。

在python中所有資料都是圍繞物件這個概念來構建的，物件包含一些基本的資料型別：數字，字串，列表，元組，字典等
程式中儲存的所有資料都是物件，
一個物件（如a=1）有：
　　一個身份（id）
　　一個型別(type)
　　一個值(通過變數名a來檢視)
1 物件的型別也稱為物件的類別，python為每個型別都定製了屬於該型別特有的方法，極大地方便了開發者對資料的處理
2 建立某個特定型別的物件也稱為建立了該型別的一個例項，工廠函式的概念來源於此
4 可變物件與不可變物件
例項被建立後，身份和型別是不可變的，
如果值是不可以被修改的，則是不可變物件
如果值是可以被修改的，則是可變物件

5 容器物件
某個物件包含對其他物件的引用，則稱為容器或集合

6 物件的屬性和方法
 

屬性就是物件的值，方法就是呼叫時將在物件本身上執行某些操作的函式，使用.運算子可以訪問物件的屬性和方法，如
a=3+4j
a.real

b=[1,2,3]
b.append(4)

7 身份比較，型別比較，值比較
x=1
y=1
x is y #x與y是同一個物件，is比較的是id，即身份
type(x) is type(y) #物件的型別本身也是一個物件，所以可以用is比較兩個物件的型別的身份
x == y #==比較的是兩個物件的值是否相等


7 變數的命名規範

• 變數命名規則遵循識別符號命名規則，詳見第二篇

  8 變數的賦值操作

• 與c語言的區別在於變數賦值操作無返回值
• 鏈式賦值：y＝x＝a＝1
• 多元賦值：x,y=1,2 x,y=y,x
• 增量賦值：x+=1

二.資料型別

2.1 什麼是資料型別及資料型別分類

程式的本質就是驅使計算機去處理各種狀態的變化，這些狀態分為很多種

例如英雄聯盟遊戲，一個人物角色有名字，錢，等級，裝備等特性，大家第一時間會想到這麼表示
名字：德瑪西亞－－－－－－－－－－－－>字串
錢：10000   －－－－－－－－－－－－>數字
等級：15    －－－－－－－－－－－－>數字
裝備：鞋子，日炎斗篷，蘭頓之兆－－－－>列表
(記錄這些人物特性的是變數，這些特性的真實存在則是變數的值，存不同的特性需要用不同型別的值)

python中的資料型別
python使用物件模型來儲存資料，每一個數據型別都有一個內建的類，每新建一個數據，實際就是在初始化生成一個物件，即所有資料都是物件
物件三個特性

• 身份：記憶體地址，可以用id()獲取
• 型別：決定了該物件可以儲存什麼型別值，可執行何種操作，需遵循什麼規則，可用type()獲取
• 值：物件儲存的真實資料

注：我們在定義資料型別，只需這樣：x＝1，內部生成1這一記憶體物件會自動觸發，我們無需關心


這裡的字串、數字、列表等都是資料型別（用來描述某種狀態或者特性）除此之外還有很多其他資料，處理不同的資料就需要定義不同的資料型別

2.2 標準資料型別：

2.2.1 數字

定義：a＝1

特性：

1.只能存放一個值

2.一經定義，不可更改

3.直接訪問

分類：整型，長整型，布林，浮點，複數

2.2.1.1 整型:

Python的整型相當於C中的long型,Python中的整數可以用十進位制,八進位制,十六進位制表示。

>>> 10
10         --------->預設十進位制
>>> oct(10)
'012'      --------->八進位制表示整數時，數值前面要加上一個字首“0”
>>> hex(10)
'0xa'      --------->十六進位制表示整數時，數字前面要加上字首0X或0x

python2.*與python3.*關於整型的區別

python2.*
在32位機器上，整數的位數為32位，取值範圍為-2**31～2**31-1，即-2147483648～2147483647

在64位系統上，整數的位數為64位，取值範圍為-2**63～2**63-1，即-9223372036854775808～9223372036854775807
python3.*整形長度無限制

整型工廠函式int()

class int(object):
    """
    int(x=0) -> int or long
    int(x, base=10) -> int or long
    
    Convert a number or string to an integer, or return 0 if no arguments
    are given.  If x is floating point, the conversion truncates towards zero.
    If x is outside the integer range, the function returns a long instead.
    
    If x is not a number or if base is given, then x must be a string or
    Unicode object representing an integer literal in the given base.  The
    literal can be preceded by '+' or '-' and be surrounded by whitespace.
    The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
    interpret the base from the string as an integer literal.
    >>> int('0b100', base=0)
    """
    def bit_length(self): 
        """ 返回表示該數字的時佔用的最少位數 """
        """
        int.bit_length() -> int
        
        Number of bits necessary to represent self in binary.
        >>> bin(37)
        '0b100101'
        >>> (37).bit_length()
        """
        return 0

    def conjugate(self, *args, **kwargs): # real signature unknown
        """ 返回該複數的共軛複數 """
        """ Returns self, the complex conjugate of any int. """
        pass

    def __abs__(self):
        """ 返回絕對值 """
        """ x.__abs__() <==> abs(x) """
        pass

    def __add__(self, y):
        """ x.__add__(y) <==> x+y """
        pass

    def __and__(self, y):
        """ x.__and__(y) <==> x&y """
        pass

    def __cmp__(self, y): 
        """ 比較兩個數大小 """
        """ x.__cmp__(y) <==> cmp(x,y) """
        pass

    def __coerce__(self, y):
        """ 強制生成一個元組 """ 
        """ x.__coerce__(y) <==> coerce(x, y) """
        pass

    def __divmod__(self, y): 
        """ 相除，得到商和餘數組成的元組 """ 
        """ x.__divmod__(y) <==> divmod(x, y) """
        pass

    def __div__(self, y): 
        """ x.__div__(y) <==> x/y """
        pass

    def __float__(self): 
        """ 轉換為浮點型別 """ 
        """ x.__float__() <==> float(x) """
        pass

    def __floordiv__(self, y): 
        """ x.__floordiv__(y) <==> x//y """
        pass

    def __format__(self, *args, **kwargs): # real signature unknown
        pass

    def __getattribute__(self, name): 
        """ x.__getattribute__('name') <==> x.name """
        pass

    def __getnewargs__(self, *args, **kwargs): # real signature unknown
        """ 內部呼叫 __new__方法或建立物件時傳入引數使用 """ 
        pass

    def __hash__(self): 
        """如果物件object為雜湊表型別，返回物件object的雜湊值。雜湊值為整數。在字典查詢中，雜湊值用於快速比較字典的鍵。兩個數值如果相等，則雜湊值也相等。"""
        """ x.__hash__() <==> hash(x) """
        pass

    def __hex__(self): 
        """ 返回當前數的 十六進位制 表示 """ 
        """ x.__hex__() <==> hex(x) """
        pass

    def __index__(self): 
        """ 用於切片，數字無意義 """
        """ x[y:z] <==> x[y.__index__():z.__index__()] """
        pass

    def __init__(self, x, base=10): # known special case of int.__init__
        """ 構造方法，執行 x = 123 或 x = int(10) 時，自動呼叫，暫時忽略 """ 
        """
        int(x=0) -> int or long
        int(x, base=10) -> int or long
        
        Convert a number or string to an integer, or return 0 if no arguments
        are given.  If x is floating point, the conversion truncates towards zero.
        If x is outside the integer range, the function returns a long instead.
        
        If x is not a number or if base is given, then x must be a string or
        Unicode object representing an integer literal in the given base.  The
        literal can be preceded by '+' or '-' and be surrounded by whitespace.
        The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
        interpret the base from the string as an integer literal.
        >>> int('0b100', base=0)
        # (copied from class doc)
        """
        pass

    def __int__(self): 
        """ 轉換為整數 """ 
        """ x.__int__() <==> int(x) """
        pass

    def __invert__(self): 
        """ x.__invert__() <==> ~x """
        pass

    def __long__(self): 
        """ 轉換為長整數 """ 
        """ x.__long__() <==> long(x) """
        pass

    def __lshift__(self, y): 
        """ x.__lshift__(y) <==> x<<y """
        pass

    def __mod__(self, y): 
        """ x.__mod__(y) <==> x%y """
        pass

    def __mul__(self, y): 
        """ x.__mul__(y) <==> x*y """
        pass

    def __neg__(self): 
        """ x.__neg__() <==> -x """
        pass

    @staticmethod # known case of __new__
    def __new__(S, *more): 
        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
        pass

    def __nonzero__(self): 
        """ x.__nonzero__() <==> x != 0 """
        pass

    def __oct__(self): 
        """ 返回改值的 八進位制 表示 """ 
        """ x.__oct__() <==> oct(x) """
        pass

    def __or__(self, y): 
        """ x.__or__(y) <==> x|y """
        pass

    def __pos__(self): 
        """ x.__pos__() <==> +x """
        pass

    def __pow__(self, y, z=None): 
        """ 冪，次方 """ 
        """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
        pass

    def __radd__(self, y): 
        """ x.__radd__(y) <==> y+x """
        pass

    def __rand__(self, y): 
        """ x.__rand__(y) <==> y&x """
        pass

    def __rdivmod__(self, y): 
        """ x.__rdivmod__(y) <==> divmod(y, x) """
        pass

    def __rdiv__(self, y): 
        """ x.__rdiv__(y) <==> y/x """
        pass

    def __repr__(self): 
        """轉化為直譯器可讀取的形式 """
        """ x.__repr__() <==> repr(x) """
        pass

    def __str__(self): 
        """轉換為人閱讀的形式，如果沒有適於人閱讀的解釋形式的話，則返回直譯器課閱讀的形式"""
        """ x.__str__() <==> str(x) """
        pass

    def __rfloordiv__(self, y): 
        """ x.__rfloordiv__(y) <==> y//x """
        pass

    def __rlshift__(self, y): 
        """ x.__rlshift__(y) <==> y<<x """
        pass

    def __rmod__(self, y): 
        """ x.__rmod__(y) <==> y%x """
        pass

    def __rmul__(self, y): 
        """ x.__rmul__(y) <==> y*x """
        pass

    def __ror__(self, y): 
        """ x.__ror__(y) <==> y|x """
        pass

    def __rpow__(self, x, z=None): 
        """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
        pass

    def __rrshift__(self, y): 
        """ x.__rrshift__(y) <==> y>>x """
        pass

    def __rshift__(self, y): 
        """ x.__rshift__(y) <==> x>>y """
        pass

    def __rsub__(self, y): 
        """ x.__rsub__(y) <==> y-x """
        pass

    def __rtruediv__(self, y): 
        """ x.__rtruediv__(y) <==> y/x """
        pass

    def __rxor__(self, y): 
        """ x.__rxor__(y) <==> y^x """
        pass

    def __sub__(self, y): 
        """ x.__sub__(y) <==> x-y """
        pass

    def __truediv__(self, y): 
        """ x.__truediv__(y) <==> x/y """
        pass

    def __trunc__(self, *args, **kwargs): 
        """ 返回數值被擷取為整形的值，在整形中無意義 """
        pass

    def __xor__(self, y): 
        """ x.__xor__(y) <==> x^y """
        pass

    denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 分母 = 1 """
    """the denominator of a rational number in lowest terms"""

    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 虛數，無意義 """
    """the imaginary part of a complex number"""

    numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 分子 = 數字大小 """
    """the numerator of a rational number in lowest terms"""

    real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 實屬，無意義 """
    """the real part of a complex number"""

int

class int(object):
    """
    int(x=0) -> integer
    int(x, base=10) -> integer
    
    Convert a number or string to an integer, or return 0 if no arguments
    are given.  If x is a number, return x.__int__().  For floating point
    numbers, this truncates towards zero.
    
    If x is not a number or if base is given, then x must be a string,
    bytes, or bytearray instance representing an integer literal in the
    given base.  The literal can be preceded by '+' or '-' and be surrounded
    by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
    Base 0 means to interpret the base from the string as an integer literal.
    >>> int('0b100', base=0)
    4
    """
    def bit_length(self): # real signature unknown; restored from __doc__
        """ 返回表示該數字的時佔用的最少位數 """
        """
        int.bit_length() -> int
        
        Number of bits necessary to represent self in binary.
        >>> bin(37)
        '0b100101'
        >>> (37).bit_length()
        6
        """
        return 0

    def conjugate(self, *args, **kwargs): # real signature unknown
        """ 返回該複數的共軛複數 """
        """ Returns self, the complex conjugate of any int. """
        pass

    @classmethod # known case
    def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        int.from_bytes(bytes, byteorder, *, signed=False) -> int
        
        Return the integer represented by the given array of bytes.
        
        The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
        
        The byteorder argument determines the byte order used to represent the
        integer.  If byteorder is 'big', the most significant byte is at the
        beginning of the byte array.  If byteorder is 'little', the most
        significant byte is at the end of the byte array.  To request the native
        byte order of the host system, use `sys.byteorder' as the byte order value.
        
        The signed keyword-only argument indicates whether two's complement is
        used to represent the integer.
        """
        pass

    def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        int.to_bytes(length, byteorder, *, signed=False) -> bytes
        
        Return an array of bytes representing an integer.
        
        The integer is represented using length bytes.  An OverflowError is
        raised if the integer is not representable with the given number of
        bytes.
        
        The byteorder argument determines the byte order used to represent the
        integer.  If byteorder is 'big', the most significant byte is at the
        beginning of the byte array.  If byteorder is 'little', the most
        significant byte is at the end of the byte array.  To request the native
        byte order of the host system, use `sys.byteorder' as the byte order value.
        
        The signed keyword-only argument determines whether two's complement is
        used to represent the integer.  If signed is False and a negative integer
        is given, an OverflowError is raised.
        """
        pass

    def __abs__(self, *args, **kwargs): # real signature unknown
        """ abs(self) """
        pass

    def __add__(self, *args, **kwargs): # real signature unknown
        """ Return self+value. """
        pass

    def __and__(self, *args, **kwargs): # real signature unknown
        """ Return self&value. """
        pass

    def __bool__(self, *args, **kwargs): # real signature unknown
        """ self != 0 """
        pass

    def __ceil__(self, *args, **kwargs): # real signature unknown
        """
        整數返回自己
        如果是小數
         math.ceil(3.1)返回4
        """
        """ Ceiling of an Integral returns itself. """
        pass

    def __divmod__(self, *args, **kwargs): # real signature unknown
        """ 相除，得到商和餘數組成的元組 """
        """ Return divmod(self, value). """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __float__(self, *args, **kwargs): # real signature unknown
        """ float(self) """
        pass

    def __floordiv__(self, *args, **kwargs): # real signature unknown
        """ Return self//value. """
        pass

    def __floor__(self, *args, **kwargs): # real signature unknown
        """ Flooring an Integral returns itself. """
        pass

    def __format__(self, *args, **kwargs): # real signature unknown
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getnewargs__(self, *args, **kwargs): # real signature unknown
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __index__(self, *args, **kwargs): # real signature unknown
        """ 用於切片，數字無意義 """
        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
        pass

    def __init__(self, x, base=10): # known special case of int.__init__
        """ 構造方法，執行 x = 123 或 x = int(10) 時，自動呼叫，暫時忽略 """
        """
        int(x=0) -> integer
        int(x, base=10) -> integer
        
        Convert a number or string to an integer, or return 0 if no arguments
        are given.  If x is a number, return x.__int__().  For floating point
        numbers, this truncates towards zero.
        
        If x is not a number or if base is given, then x must be a string,
        bytes, or bytearray instance representing an integer literal in the
        given base.  The literal can be preceded by '+' or '-' and be surrounded
        by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
        Base 0 means to interpret the base from the string as an integer literal.
        >>> int('0b100', base=0)
        4
        # (copied from class doc)
        """
        pass

    def __int__(self, *args, **kwargs): # real signature unknown

        """ int(self) """
        pass

    def __invert__(self, *args, **kwargs): # real signature unknown
        """ ~self """
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lshift__(self, *args, **kwargs): # real signature unknown
        """ Return self<<value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    def __mod__(self, *args, **kwargs): # real signature unknown
        """ Return self%value. """
        pass

    def __mul__(self, *args, **kwargs): # real signature unknown
        """ Return self*value. """
        pass

    def __neg__(self, *args, **kwargs): # real signature unknown
        """ -self """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __or__(self, *args, **kwargs): # real signature unknown
        """ Return self|value. """
        pass

    def __pos__(self, *args, **kwargs): # real signature unknown
        """ +self """
        pass

    def __pow__(self, *args, **kwargs): # real signature unknown
        """ Return pow(self, value, mod). """
        pass

    def __radd__(self, *args, **kwargs): # real signature unknown
        """ Return value+self. """
        pass

    def __rand__(self, *args, **kwargs): # real signature unknown
        """ Return value&self. """
        pass

    def __rdivmod__(self, *args, **kwargs): # real signature unknown
        """ Return divmod(value, self). """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
        """ Return value//self. """
        pass

    def __rlshift__(self, *args, **kwargs): # real signature unknown
        """ Return value<<self. """
        pass

    def __rmod__(self, *args, **kwargs): # real signature unknown
        """ Return value%self. """
        pass

    def __rmul__(self, *args, **kwargs): # real signature unknown
        """ Return value*self. """
        pass

    def __ror__(self, *args, **kwargs): # real signature unknown
        """ Return value|self. """
        pass

    def __round__(self, *args, **kwargs): # real signature unknown
        """
        Rounding an Integral returns itself.
        Rounding with an ndigits argument also returns an integer.
        """
        pass

    def __rpow__(self, *args, **kwargs): # real signature unknown
        """ Return pow(value, self, mod). """
        pass

    def __rrshift__(self, *args, **kwargs): # real signature unknown
        """ Return value>>self. """
        pass

    def __rshift__(self, *args, **kwargs): # real signature unknown
        """ Return self>>value. """
        pass

    def __rsub__(self, *args, **kwargs): # real signature unknown
        """ Return value-self. """
        pass

    def __rtruediv__(self, *args, **kwargs): # real signature unknown
        """ Return value/self. """
        pass

    def __rxor__(self, *args, **kwargs): # real signature unknown
        """ Return value^self. """
        pass

    def __sizeof__(self, *args, **kwargs): # real signature unknown
        """ Returns size in memory, in bytes """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    def __sub__(self, *args, **kwargs): # real signature unknown
        """ Return self-value. """
        pass

    def __truediv__(self, *args, **kwargs): # real signature unknown
        """ Return self/value. """
        pass

    def __trunc__(self, *args, **kwargs): # real signature unknown
        """ Truncating an Integral returns itself. """
        pass

    def __xor__(self, *args, **kwargs): # real signature unknown
        """ Return self^value. """
        pass

    denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """the denominator of a rational number in lowest terms"""

    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
第三篇：python基礎之資料型別與變數
     
 一.變數
1 什麼是變數之宣告變數

#變數名=變數值
age=18
gender1='male' 
gender2='female'

2 為什麼要有變數變數作用：“變”=>變化，“量”=>計量/儲存狀態程式的執行本質是一系列狀態的變化，變數的目的就是用來儲存狀態，變數值的變化就 

  
 

    

    
    
Python之路【第三篇】:Python基礎之雜貨鋪
     
 對齊   表示   microsoft   小數點   true   per   字符串   orm   bsp   字符串格式化
Python的字符串格式化有兩種方式：百分號方式、format方式
百分號的方式相對來說比較老，而format方式則是比較先進的方式，企圖替換古老的方式，目前兩者並存。
1 

  
 

    

    
    
第四篇：python基礎之雜貨鋪
     
  
 
 　　在這一篇中我們將對上幾篇的Python零碎的知識進行補充，即字串的格式化輸出，以及深淺拷貝，接下來我們將對這兩種進行一一介紹。 
 一、字串格式化輸出 
 　　關於字串的格式化輸出，我們需要了解為什麼需要字串的格式化，同時掌握格式化輸出的兩種用法：百分號方式、format方式。接下來我們就這兩種 

  
 

    

    
    
python基礎之資料型別與算術運算
     
 
							
							
							一.python的編碼規範


  1.分號：不要在行尾加分號，也不要使用分號將兩條命令放在同一行
  
  2.行長度：一般情況下每行不要超過80個字元
  
  3.括號：寧缺毋濫的使用括號
  
  4.縮排：使用4個空格來縮排程式碼
  
  5.空行： 

  
 

    

    
    
python學習第三天：python基礎（基礎資料型別和變數）
     
 註釋 
以  # 開頭的語句是註釋，如，註釋不會被編譯執行； 
格式 
當語句以冒號:結尾時，縮排的語句視為程式碼塊。按照約定俗成的管理，應該始終堅持使用4個空格的縮排（在文字編輯器中，需要設定把Tab自動轉換為4個空格，確保不混用Tab和空格）。 
如，而其中這張圖中紅框框裡的是程式碼塊 

  
 

    

    
    
第三篇：python函數
     
 名稱   bsp   一行   turn   內置   提高   none   def   簡單   1、python函數
函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。
函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可 

  
 

    

    
    
第五篇：python基礎_5
     
 執行過程   ini   間接   ray   復雜   func   時間   基於   time   本篇內容

協程函數
遞歸
二分法
import語句
from...import語句
模塊搜索路徑
包的導入
軟件開發規範
logging模塊的使用

 
一、 協程函數
 1.定義
協程函數就是使用了y 

  
 

    

    
    
第八篇：python基礎_8 面向對象與網絡編程
     
 pro   size   賬單   socket   基礎   發生   多態   proc   client   本篇內容

接口與歸一化設計
多態與多態性
封裝
面向對象高級
異常處理
網絡編程

 
一、 接口與歸一化設計
1.定義
（1）歸一化讓使用者無需關心對象的類是什麽，只需要知道這些對象都具備某 

  
 

    

    
    
第三章：Linux基礎之許可權操作
     
 
                Linux許可權管理是Linux中一個十分重要的概念，也是系統安全性的重要保障。這裡主要介紹Linux的基本許可權和預設許可權，通過理論講解與實驗演示，可以詳細瞭解到許可權的相關操作及其重要性。


檔案許可權


[[email protected] ~]# ls 

  
 

    

    
    
第二篇：python基礎之核心風格
     
 一.語句和語法


＃：註釋

\:轉譯回車，繼續上一行，在一行語句較長的情況下可以使用其來切分成多行，因其可讀性差所以不建議使用
；：將兩個語句連線到一行，可讀性差，不建議使用
：：將程式碼的頭和體分開
語句（程式碼塊）用縮排方式體現不同的程式碼級別，建議採用4個空格（不要使用tab）
p 

  
 

    

    
    
快取第三篇：redis入門之下載安裝和命令列使用
     
 
							
							
							
  今天上午整理了一下redis的入門必備資料，以備後續使用。到官網看了下穩定版到3.2,測試版到4.0了。但我下載3.2解壓發現沒有redis-server，一直無法正常用命令列啟動。就在GitHub上找了windows-x64的下載地址，才算一切正常。

 

  
 

    

    
    
JavaScript高階程式設計第三版學習筆記(一)之資料型別區分詳談
     
 　　null、NaN、undefined三者的區別是什麼？ 
　　在初次接觸到JavaScript的時候，傻傻的分不清null、NaN、undefined三者到底區別何在，在實際的專案開發中也因為這個問題而困惑久矣。針對這個問題，我特意查找了多方資料，在筆記本上做了詳細的分析記錄，但是由於紙質資料不便於攜帶、 

  
 

    

    
    
python基礎之資料型別
     
 
                資料型別：

基礎資料型別：

整數：正負整數

浮點數：也就是小數，一般用科學計數法表示，如：1.02e-12

布林值：True/False，其實就是整數，True=1, False=0

字串：用單引號或則雙引號引用的資料。

空值：None，表示沒有物件，統一標準佔位 

  
 

    

    
    
JavaScript之資料型別與變數
     
 
                4.1 資料型別和變數

資料型別實際上就是資料的一種描述，任何一門程式語言都可以處理多種型別的資料，只是有的是強型別(Java) ，有的弱型別的(JavaScipt)。



JavaScipt資料型別有三種：

1、基本資料型別

JS中基本資料型別主要由3種組成：數值資 

  
 

    

    
    
Python基礎第三篇：函數
     
 turn   說明   代碼   名稱   維護   span   大小寫   div   邏輯   一、Python函數介紹
1.函數的作用

規範代碼使代碼變得邏輯性更強
提高可讀性，方便管理，降低維護成本，以及降低代碼冗余

 
函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。
2.函 

  
 

    

    
    
Python開發【第五篇】：Python基礎之2
     
 對齊方式   dex   字符串   後退   ring   lag   nic   有效   func   字符串格式化
Python的字符串格式化有兩種方式: 百分號方式、format方式
百分號的方式相對來說比較老，而format方式則是比較先進的方式，企圖替換古老的方式，目前兩者並存。[PEP-310 

  
 

    

    
    
Python開發【第四篇】：Python基礎之函數
     
 nco   pos   *args   更強   三元   sequence   hunk   ins   att   

三元運算
三元運算（三目運算），是對簡單的條件語句的縮寫。

# 書寫格式

result = 值1 if 條件 else 值2

# 如果條件成立，那麽將 “值1” 賦值給result 

  
 

    

    
    
Python成長之路【第五篇】：Python基礎之文件處理
     
 閱讀   關註   src   文件路徑   程序   opened   IT   寫入   文件操作   一、文件操作
1、介紹
計算機系統分為：計算機硬件，操作系統，應用程序三部分。
 
我們用python或其他語言編寫的應用程序若想要把數據永久保存下來，必須要保存於硬盤中，這就涉及到應用程序要操作硬件， 

  
 

    

    
    
Python成長之路【第五篇】：Python基礎之裝飾器
     
 brush   urn   新功能   clas   現在   hide   rom   接收   調用   一、什麽是裝飾器
裝飾：裝飾既修飾，意指為其他函數添加新功能
器：器既函數
裝飾器定義：本質就是函數，功能是為其他函數添加新功能
二、裝飾器需要遵循的原則
1、不能修改裝飾器的源代碼（開放封閉原則）
 

  
 

    

    
    
Python成長之路【第五篇】：Python基礎之模塊
     
 module   應用程序   過程   解釋器   amp   之路   Python標準庫   pre   使用   模塊&包
模塊（module）的概念：
在計算機程序開發的過程中，隨著程序代碼越寫越多，在一個文件裏代碼就會越來越長，越來越不容易維護。為了編寫可維護的代碼，我們把很多函數分組，分