因為需求, 需要用到py, 所以來學學py, 因為有java基礎 一小時入門py語法是不成問題的, 但是僅僅入門基礎語法而已, 不涉及算法,不涉及大數據,機器學習,人工智能, 但是py這么火爆,就在于這幾個分支遍地開花,后續的路還好長啊

py的語法是真的簡單, 跟java比,真的簡單太多了, 而且 他的代碼很有條理, 因為他是嚴格控制縮進的,在一個縮進塊中,就好比一個隱形的大括號一樣,限制著變量的聲明周期

---

命名:文件/標識符/關鍵字

• 標識符: 程序員定義的變量名,函數名
  • 可以由字母數字下劃線組成
  • 不能用數字開頭
  • 不能和已經存在的關鍵字重名
• 關鍵字: Python內置的標識符
• 文件名: 不推薦文件名以數字開頭,否則不能通過import關鍵字導入其他文件使用

注釋

• 單行注釋使用 #
• 多行注釋使用 ''' XXX '''

算數運算符

+ - * / == != > < >= <= %

加減乘除的使用方法和其他語言完全相同

//

取整數 求商

          
            9//2=4
          
        

**
冪運算

          
            2**3=8
          
        

列表常見運算

          
            print([1,2]+[3,4])#[1, 2, 3, 4]
          
        

          
            print([1,2]*2)#[1, 2, 1, 2]
          
        

          
            print(3 in [1,2,3])#True
print(3 not in [1,2,3])#False
          
        

對全局列表使用+=操作,相當于extend函數**

          
            def test(list):
    list+=list
    print(list)#[1, 3, 4, 1, 3, 4]
gl_list=[1,3,4]
test(gl_list)
print(gl_list)#[1, 3, 4, 1, 3, 4]
          
        

全局變量使用 = 賦值

不可變 全局變量 在函數內部 使用 = ,這種賦值操作, 原全局變量不會被影響

          
            gl_num=1
def test(num):
    print(num)#1
    num=2
    print(num)#2
    num+=3
    print(num)#5
test(gl_num)
print(gl_num)#1
          
        

在函數中, 如果 全局變量是可變類型 的, 如果在函數中往這個全局變量中添加內容了, 全局變量的值會受到影響

          
            gl_num=[1,3,4]
def test(num):
    print(num)#[1, 3, 4]
    num+=[1]
    print(num)#[1, 3, 4, 1]
test(gl_num)
print(gl_num)#[1, 3, 4, 1]
          
        

賦值運算符

          
            =
+=
-=
*=
/=      除法賦值運算符
//=     取整賦值運算符
%=      取模賦值運算符
**=     冪賦值運算符
          
        

轉義運算符

          
            \t 在控制臺上輸出一個制表符
\n 在控制臺上輸出一個換行符
\\ 反斜杠符
\' 輸出單引號
\r 回車
          
        

變量

變量的命名:

• 區分大小寫 Abc != abc
• 為了保證代碼的質量, = 兩邊預留兩個空格
• 所有單詞全是小寫字節
• 單詞之間使用下劃線連接 first_name

---

在py中,變量的類型是有不需要程序員指定,因為它是在運行時,由解釋器自己推斷出來的

例:

          
            name="小明"    # str  字符串類型
age=18         # int 整形
sex= True      # bool 布爾類型  True False 首字母都是大寫
height=1.78    # float 單精度小數類型
weiht=75.0     # float
weiht2=75      # int
          
        

• 數字型
  • int: 整形
  • float: 浮點型
  • bool:布爾型
    • True: 所有非0的數字
    • False:0
  • 復數類型: complex
    • 主要用于科學計算
• 非數字型:
  • str:字符串
  • 列表
  • 元組
  • 字典
    ```py
    在py2.0中
    type(2 ** 32) --> int
    type(2 ** 64) --> long

在py3.0中 全部都是 int, 在py中的計算能力,完爆其他語言

          
            print(type(2 ** 32))
print(type(2 ** 64))
print(type(2 ** 128))
print(type(2 ** 256))
print(type(2 ** 512))
print(type(2 ** 1024))
          
        

type函數可以直接查看變量的類型

          
            print(type(name))  # 結果 
            
          
        

• 相同類型之間的計算規則
  • 數值型變量之間的計算
  • bool型, True被轉換成1 False被轉換成0
  • 字符串之間使用 + 拼接成連續串
• 不同類型數據之間的計算規則
  • 字符串 * 整數 實現重復拼接串

          
            print("$"*10)#$$$$$$$$$$
          
        

---

• 數字型變量和字符串之間 不能 進行其他類型操作

          
            d=10
f="10.5"
g=True
print(d+f+g)#TypeError: unsupported operand type(s) for +: 'int' and 'str'
          
        

• 變量的輸入輸出

          
            passwd = input("請輸入密碼")
print(passwd)
print(type(passwd))
          
        

• 類型轉換

          
            類型轉換函數
int(X)#將輸入轉換成整數
float(X)#將輸入轉換成浮點型
          
        

• 變量的格式化輸出

          
            %s: 字符串
%d: 有符號十進制整數  %06d 表示輸出的整形顯示的位數, 不足的地方使用0補全
%f: 浮點型  %.02f 表示顯示小數點后兩位
%%: 輸出%

q=999
print("格式化的字符串是  %06d "%q)#000999
w=123.123456
e=123.123456
r=123.123456
print("格式化的字符串%.2f"%w)#123.12
print("%.1f %.2f %.3f"% (w,e,r))#123.1 123.12 123.123
t=0.25
print("%.2f%%" % t)#0.25%
          
        

• 全局變量

全局變量推薦定義在全部代碼的最上方

全局變量的推薦命名規則

          
            g_XXX   gl_XXX
          
        

如何在 函數內部修改全局變量?

先使用 global 進行修飾,再修改

高級變量

如: 列表 元組 字典 字符串 公共方法

在python中全部的非數字型變量都支持以下特點

1. 都是一個序列, 也可以理解成容器
2. 取值 []
3. 遍歷 for in
4. 計算長度,最大/小 值 比較 刪除
5. 連接+ 重復*
6. 切片

列表

列表,在java叫數組

雖然列表可以存儲不同類型的數據,但是絕大多數情況下, 用它存儲相同類型的數據

使用 [] 定義, 數據之間使用 , 分隔
列表的索引從 0 開始

py中提供的常用操作

          
            python 中對列表提供的操作
1. 增加   列表insert(索引,數據)      在指定位置插入數據
          列表append(數據)           在末尾追加數據
          列表extend(列表2)         將列表2的數據追加到列表
2. 修改   列表[索引]=新值            修改指定索引的數據
3. 刪除   del列表[索引]              刪除指定索引的數據
          列表.remove[數據]         刪除第一個出現的指定的數據
          列表.pop                  刪除末尾的數據
          列表.pop(索引)            刪除指定索引的數據
          列表.clear                清空列表
4. 統計   len(列表)                 列表長度
          列表.count(數據)          數據在列表中出現的次數
5. 排序   列表.sort()               升序
          列表.sort(reserve=true)   降序排序
          列表.reserve()            逆序,反轉
6. 取索引  列表.index(數據)          返回數據在列表中的索引
          
        

• 把變量從內存中刪除掉

          
            del name_list[0]
print(name_list[0])
          
        

• 第一個參數位置的self 直接忽略就行
• 迭代

          
            for name in name_list:
    print(name)
          
        

元組

元組 Tuple 和列表類似,但是元組的元素 不能修改

通常使用 元組 存儲不同類型的數據

元組表示多個元素組成的序列

下標從0開始
用戶存儲一串信息, 數據之間使用 逗號 分隔

• 定義元組

          
            info_tuple = ("zhangsan",18,1.75)
print(type(info_tuple)) # 
            
          
        

• 取值

          
            print(info_tuple[0])
print(info_tuple[1])
print(info_tuple[2])
# print(info_tuple[3])#tuple index out of range
          
        

• 取索引

          
            print(info_tuple.index("zhangsan")) # 0
          
        

• 統計計數

          
            print(info_tuple.count("zhangsan")) # 1
          
        

• 定義空元組,一般是不定義空元組的,但是沒意義,因為不能再修改

          
            empty_tuple = ()
print(type(empty_tuple))#
            
          
        

• 定義一個元素的元組

          
            single_touble1 = (5) # 解釋器會忽略兩個小括號
print(type(single_touble1))# 
            
                 被解釋器解釋成了int類型

single_touble2 = (5,) # 多加上一個逗號
print(type(single_touble2))#
              
            
          
        

• 元組的應用場景
  • 作為入參: 可以使得函數一次性接受多個參數
  • 讓列表不可變,保護數據的安全
  • 作為返回值: 可以使函數一次性返回多個值
  • 格式化字符串, 在print函數中,格式化字符串時, 格式化字符串后面的() 本質上就是一個元組

例:

          
            print("年齡: %d   姓名:%s"%(123,"小明"))
info_tuple = ("zhangsan",18,1.75)
print(type(info_tuple)) # 
            
              
info_str="姓名:%s  年齡: %d  身高%.2f "% info_tuple
print(info_str)
            
          
        

• 列表轉元組

          
            my_list = [1,3,4,5]
my_list = tuple(my_list)
print(type(my_list)) # my_list
          
        

• 函數返回元組

          
            def mea():
    a=1
    b=2
    return (a,b)
    
# 接受
result = mea()

# 使用
print(result[0])
print(result[1])

# 也可以這樣接收, 注意, 變量的格式和元組的數保持一致
gl_a, gl_b = mea()
          
        

字典

字典是 無序對象 的集合 類似java中的 map,或者說是java中的一個對象

說它是無序,使用print輸出時,每次的順序不唯一

因為我們只關心通過key 取出 保存的數據,而不關心存儲的順序

字典使用{}定義

字典使用鍵值對存儲數據, 鍵值對使用 逗號分隔

key 是索引,并且是 不可變類型的變量才能當key (列表,字典是可變類型,不能當成key)

value 是數據

鍵和值之間使用 : 冒號分隔

鍵是唯一的

值任意數據類型

*　定義字典

          
            person={"name":"張三","age":23}
          
        

• 取值

          
            # 取值
print(person["name"])# 入參位置的name是key
# print(xiaoming["name123"])# KeyError: 'name123'   key不存在,程序會報錯
          
        

• 添加修改

          
            # 添加/修改, 如果key存在了, 就是修改, key不存在就是添加
person["height"]=1.78
print(person)
          
        

• 刪除

          
            person.pop("age")
print(person)
          
        

• 統計鍵值對的數量

          
            print(len(person))
          
        

• 合并字典

          
            new_dir={"class":"大一"}
person.update(new_dir) # 如果被合并的字典中包含原有的鍵值對, 會覆蓋舊值
print(person)
          
        

• 清空字典xiaoming

          
            xiaoming.clear()
print(xiaoming)
          
        

• 遍歷

          
            for k in person:
    print(" value = %s "%person[k])
          
        

• 字典和列表搭配使用

          
            將多個字典存入一個列表中,然后遍歷列表對實現對字典批量處理的動作
list = [
        {},
        {},
        {}
        ]
          
        

if分支判斷語句

          
            if 要頂格寫

if 條件1:
    XXX
elif ()or()or():
    XXX
else:
    XXX

嚴格控制縮進, tab 和 空格不能混用,容易亂
          
        

邏輯運算符

          
            與  and
或  or
非  not

條件1 and 條件2
條件1 or 條件2

對條件取反
not 條件1
not 條件2
          
        

循環

• for循環

          
            for 變量 in 集合:
    XXX
else:
    XXX
          
        

• while循環

          
            i=0
while i<5:
    print("i= %d"%i)
    #i=i+1
    i+=1
          
        

函數

格式如下

          
            def 函數名():
    XXX
    XXX

def 函數名():
    XXX
    XXX
    return XXX
          
        

內置函數

• 隨機數

          
            import random
n = random.randint(1,5)# 1 <= n <= 5
m = random.randint(5,5)# n = 5
# s = random.randint(10,5)# 第一個數大于第二個數則保存
print("age== %d "%n)
          
        

缺省參數

• 缺省參數, 簡化人們的編碼

          
            gl_list=[5,126,7]
gl_list.sort()
print(gl_list) # 默認正序
gl_list.sort(reverse=True) # 缺省參數位置,可以設置逆序
print(gl_list)
          
        

• 指定缺省參數的默認值

          
            def print_info(name,gender=True):
    default_gender="男生"
    if not gender:
        default_gender = "女生"

    print("%s 是 %s"%(name,default_gender))

print_info("小明")
print_info("小明",False)
          
        

注意事項: 缺省參數必須保證它出現在 !!! 參數列表的末尾 !!!

• 如何調用含有多個參數, 如果有多個參數的話, 中間位置的參數最好也設置上默認值

          
            def print_info(name,age="",gender=True):
    default_gender="男生"
    if not gender:
        default_gender = "女生"

    print("%s 是 %s"%(name,default_gender))

print_info("小明")
print_info("小明",gender=False)
          
        

• 多值參數

在參數名前添加一個 * 可以接收元組

在參數名前添加兩個 * 可以接收字典

習慣用下面的方式命名:

• *args :存放元組
• **kw :存放字典數據

          
            
def demo(num,*nums,**person):
    print(num)
    print(nums)
    print(person)

demo(1)
'''
1
()
{}
'''
demo(1,23,4,5,6)

'''
1
(23, 4, 5, 6)
{}
'''

demo(1,23,4,5,6,name="張三",age=18)
'''
1
(23, 4, 5, 6)
{'name': '張三', 'age': 18}
'''



# 對比去除* 的寫法, 其實用戶在使用時變麻煩了,多增加了一個小括號
def print_info1(name):
    print(name)

print_info1((1,2,3,4))#(1, 2, 3, 4)
          
        

元組和字段的拆包

          
            def demo(*args,**kwargs):
    print(args)
    print(kwargs)

gl_nums=(1,2,3)
gl_dir={"name":"李四","age":12}

demo(gl_nums,gl_dir)
'''
 下面的運行結果其實是差強人意的, 需要進行拆包
((1, 2, 3), {'name': '李四', 'age': 12})
{}
'''

# 不拆包,直接調用
demo(1,2,3,name="李四",age=123)
'''
(1, 2, 3)
{'name': '李四', 'age': 123}
'''

# 拆包
demo(*gl_nums,**gl_dir)
'''
(1, 2, 3)
{'name': '李四', 'age': 12}
'''