str

str是Python內(nèi)置的一種數(shù)據(jù)類型，稱為字符串组题。所謂字符串葫男，就是由零個或多個字符組成的有限序列，他是一個不可變量崔列。

• str可進行的操作

str1 = 'hello,world!'
字符串首字母大寫

# 只會把整個字符串的首字母變大寫
str1.capitalize()  # Hello,world!
# 所有單詞的首字母都變成大寫
str1.title()  # Hello,World!

子符串變?nèi)髮?/p>

str1.upper()

字符串變?nèi)?/p>

str1.lower()

判斷字符串是否是全小寫

str1.islower()

查找 find - 若查找的內(nèi)容存在梢褐，返回內(nèi)容所在位置的索引，不存在返回 -1赵讯；
index - 若查找的內(nèi)容不存在盈咳，會報錯

str1.find('or')  # True
str1.find('shit')  # False
str1.index('shit')  # 程序報錯

字符串是否以某字符開頭

str1.startswith('he')
str1.startswith('He')

字符串是否以某字符結(jié)尾,長用于查看文件類型

str1.endswith('exe')

在字符串左右填充*字符，字符串居中边翼，共50個字符

str1.center(50, '*')

字符串右對齊,在左填充*

str1.rjust(50, '*')

字符串左對齊,在右填充*

str1.ljust(50, '*')

str2 = 'abcde123456'
判斷字符串是否由數(shù)字組成

print(str2.isdigit())

判斷字符串是否由字母組成

print(str2.isalpha())

判斷字符串是否由數(shù)字和字母組成

print(str2.isalnum())

從0開始取鱼响，取到1

print(str2[:2])  # ab

取某個位置上的字符，從0開始數(shù),如取c组底，則輸入2

print(str2[2])

取多個字符,如取cde丈积，則是第2-4個字符，輸入2:5债鸡，從2開始取江滨，取到5-1=4

print(str2[2:5])

從第二個開始，取到最后

print(str2[2:])

從第2個開始取厌均，每2個取1個

print(str2[2::2])

從第0個開始取唬滑，每2個取1個

print(str2[::2])

從最后一個開始往前面取

print(str2[::-1])

從后面開始取，最后一個為-1，如取6晶密，輸入-1

print(str2[-1])

從后面取多個字符擒悬，取65

print(str2[-1:-3, -1])

取45

print(str2[-3:-1])

str3 = ' jjhggs@163.com '
去掉左右兩邊的空格，此處的strip方法沒有副作用惹挟，str3字符串是不變的

print(str3.strip())

去掉右邊的空格

print(str3.rstrip())

去掉左邊的空格

print(str3.lstrip())

str4 = 'dgsa dshgd'
替換字符串中某個字符

print(str.replace(' ', '')  # 把字符串中的空格替換為空茄螃，相當于刪除空格 - dgsadshgd
print(str.replace('d', 'a'))  # 把字符串中的d變?yōu)閍 - agsa ashga

list

list是Phthon內(nèi)置的一種數(shù)據(jù)類型，稱為列表连锯。列表是一種有序的集合归苍，列表中的每一個元素都有自己的索引（下標），索引從0開始运怖，根據(jù)索引和元素值可以對列表進行增加拼弃、刪除等操作。

• 定義一維list

列表用[ ]表示摇展，列表中的元素可以是不同數(shù)據(jù)類型吻氧，但在實際情況中，一般都是同類型數(shù)據(jù)咏连，并且強烈建議列表中放同類型的數(shù)據(jù)盯孙。定義列表有多種方式，如下：

不常用的寫法：

list1 = [0, 3, 4, 6, 98, 56]
list2 = list(ranger(1, 10))  # 生成一個1-9的列表

常用的寫法：

• 生成式

用列表的生成表達式語法創(chuàng)建列表容器祟滴，用這種語法創(chuàng)建列表之后振惰，元素已經(jīng)準備就緒，所以需要耗費較多的內(nèi)存空間垄懂，但需要數(shù)據(jù)時骑晶，取數(shù)據(jù)速度快
# 生成一個1-9的列表

list3 = [x ** 2 for x in range(1, 10)]  # 生成一個1的平方到9的平方的列表

• 生成器

這里得到的不是一個列表，而是一個生成器對象草慧，通過生成器可以獲取數(shù)據(jù)桶蛔，它不占用額外的空間存儲數(shù)據(jù)，每次需要數(shù)據(jù)的時候就通過生成器取數(shù)據(jù)漫谷，這就需要花費時間

 f = (x ** x for x in range(1, 10))  # 生成一個1的1次方到9的9次方的列表 

查看對象占用內(nèi)存空間的函數(shù)：sys.getsizeof()

sys.getsizeof(list3)
sys.getsizeof(f)

• 定義多維列表

易錯寫法：此方法不正確仔雷，因為元素的索引不正確

scores = [[0] * len(subjects)] * len(names)  

正確寫法：

scores = [[0 for _ in range(3)] for _ in range(5)]
scores = [[0] * len(subjects) for _ in range(len(names))] 

陷阱：

如果要創(chuàng)建一個list5，這個列表和list4完全相同舔示，易錯寫成下面這種方式朽寞，

list4 = [x for x in range(1, 9)]
list5 = list4

上面這種方式，表面上是創(chuàng)建了一個新的列表（一個列表就是一個對象斩郎，并且所有的一切都是對象），實際上內(nèi)存中只存在一個列表對象喻频，要理解這個問題缩宜，我們先了解下面的知識點：
cpu（內(nèi)存）分為三個部分：棧（stack），堆（heap），靜態(tài)區(qū)（數(shù)據(jù)段锻煌、只讀數(shù)據(jù)段妓布、代碼段）。棧用于存放變量宋梧，堆用于存放所有對象匣沼，變量是記錄對象在堆上的地址，假如創(chuàng)建一個變量a = 100捂龄，實際是在堆上創(chuàng)建一個對象100释涛，變量a記錄對象100在堆上的位置，并且變量a存放在棧上倦沧，所以變量實際是對對象的引用唇撬。
知道了這個原理，就很容易理解上面的問題展融，list5 = list4 實際是把對象在棧上的地址賦給了list5窖认，堆上的列表對象只有一個，棧上面有兩個變量引用了這個列表對象告希。
查看對象的身份（地址）：內(nèi)置函數(shù) - id()

# 查看對象的身份
a = 1000
b = 1000
id(a)
id(b)

查看對象被引用的次數(shù)：此處list4被引用的次數(shù)是3扑浸，一次引用是list4 ，一次引用是list5燕偶， 還有一次是執(zhí)行下面這句代碼時被引用

sys.getrefcount(list4)

正確的寫法如下：表示生成一個和list4相同的列表喝噪，把此列表（對象）在堆中的地址存在變量list5中，此時堆上面有兩個列表對象杭跪。

list5 = list4[:]

• list可進行的操作

訪問某個元素：取出列表第一個元素

f[0]

在列表末尾追加值：

f.append()  # 只能追加一個值
f = f + [600, 900]  # 可以是多個值

在列表某個位置插入值：在f[2]插入100仙逻，如果定義的位置超出了索引范圍，如果小于0涧尿，則直接在最前面插入系奉；如果大于最大索引，則直接在最后插入姑廉。

f.insert(2缺亮，100)

刪除某個元素：若這個元素不在列表內(nèi)，程序會報錯桥言，所以要先判斷這個元素是否存在于列表中

if 5000 in f:
   f.remove(5000)

刪除某個位置的元素：刪除第3個元素

del f[2]

刪除元素：pop默認刪除最后一個元素萌踱，也可以傳入?yún)?shù) - 索引 刪除某個位置的元素

f.pop()

查找某個元素的位置：查找一個元素，若此元素存在号阿，則返回這個元素的位置即索引并鸵；若此元素不存在，香醋會報錯

f.index(100)  # 在整個列表中查找元素100
f.index(100, 1, 3)  # 在第1位到第3位之間查找元素100

翻轉(zhuǎn)列表：可根據(jù)是否想改變元列表的順序選擇方法或函數(shù)扔涧，方法是直接把翻轉(zhuǎn)后的列表賦值給原列表园担，函數(shù)則是生成一個新的翻轉(zhuǎn)后的列表届谈，原列表不變。

f.reverse()  # 方法
f1 = reversed(f)  # 函數(shù)弯汰，f不變

元素排序：Python內(nèi)置的排序方法默認都是排升序（從小到大）艰山，若想排降序，可使用reverse參數(shù)咏闪，當他的值為True時翻轉(zhuǎn)曙搬，為False時不翻轉(zhuǎn)。key可以指定排序規(guī)則鸽嫂，如下例是讓其按照單詞的長度進行排序

f = ['red', 'grade', 'internationlization', 'zoo', 'classmate']
f.sort(key=str_len, reverse=True)  # 方法

def str_len(s):
    return len(s)
# len是內(nèi)置求長度的函數(shù)纵装，官方不建議使用
# 自己定義一個求列表長度的函數(shù)str_len()，return一個len(）
f1 = sorted(f, key=str_len, reverse=True)  # 函數(shù)

遍歷列表：只返回元素溪胶；返回索引和對應的元素：枚舉法enumerate

for val in f:
    print(val)
for index,val ball in enumerate(f):  # 枚舉法
    print(index, val)

• 實例

生成fibonacci序列：[1, 1, 2, 3, 5, 8, 13, 21, ...]

def fibonacci():
    current_fibonacci = [1, 1]
    for _ in range(18):
        current_fibonacci.append(current_fibonacci[-1] + current_fibonacci[-2])
    return current_fibonacci

設(shè)計一個函數(shù)搂擦，計算傳入的成績列表的平均分，要求去掉一個最高分和一個最低分

def mean(list_grade):
    grade_max = grade_min = list_grade[0]
    for val in list_grade:
        if val > grade_max:
            grade_max = val
        if val < grade_min:
            grade_min = val
    list_grade.remove(grade_max)
    list_grade.remove(grade_min)
    total = 0
    for new_val in list_grade:
        total += new_val
    return total / len(list_grade)

輸入已有學生的成績哗脖，找最高分和最低分瀑踢，并知道對應的同學名字

def seclct_name_grade():
    names = ['零零', '一一', '二二', '三三', '四四', '五五', '六六', '七七']
    grades = []
    for val in names:
        grade = int(input('輸入%s的成績：' % val))
        grades.append(grade)
    pos_max = grades.index(max(grades))
    pos_min = grades.index(min(grades))
    print('最高分學生：%s | 成績：%d' % (names[pos_max], grades[pos_max]))
    print('最低分學生：%s | 成績：%d' % (names[pos_min], grades[pos_min]))

從傳入的列表中找出第二大的元素称勋，只能用一次循環(huán)

def second(your_list):
    """
    找出列表中第二大的元素

    :param your_list: 一個全數(shù)字的列表

    :return: 列表中第二大的元素
    """
    your_max = your_second = your_list[0]
    for num in range(1, len(your_list)):
        if your_list[num] > your_max:
            your_second = your_max
            your_max = your_list[num]
        elif your_second < your_list[num] < your_max:
            your_second = your_list[num]
    return your_second

機選n注雙色球中獎號碼

6個紅色球（1 ~ 33）和1個藍色球（1 ~ 16）
彩票號碼的順序符合規(guī)則：紅色球號碼（不重復颜说，且從小到大） + 藍色球號碼雙色球

def random_select():
    """
    生成一注雙色球號碼

    :return: 一注雙色球號碼
    """
    # 生成一個1-33的列表 也看用下面這張方式red_balls = [x for x in randint(1, 33)]
    # randrange(n)默認從0開始取，取到(n - 1)
    red_balls = list(randrange(1, 34))
    all_balls = []
    for _ in range(6):
        index = randrange(len(red_balls))
        all_balls.append(red_balls[index])
        del red_balls[index]
    all_balls.sort()
    blue_ball = randint(1, 16)
    all_balls.append(blue_ball)
    return all_balls


def display(balls):
    """
    打印雙色球彩票號碼

    :param balls: 雙色球彩票號碼的列表

    :return: 打印彩票號碼的樣式
    """
    for index, ball in enumerate(balls):
        if index == len(balls) - 1:  # 遍歷到列表最后一位時屋吨，打印1個豎線
            print('|', end=' ')
        print('%02d' % ball, end=' ')  # %02d是一個整數(shù)類型的占位符桑逝，2表示這個整數(shù)的位數(shù)棘劣，若當前整數(shù)不滿2位，則在前面填充數(shù)字0
    print()


def lottery_amount():
    """
    生成n注彩票

    :return: 打印出n注彩票的號碼
    """
    n = int(input('買幾注雙色球彩票：'))
    for _ in range(n):
        display(random_select())

生成一個列表楞遏，記錄每個同學的多門課程成績

def main():
    names = ['關(guān)羽', '張飛', '趙云', '馬超', '貂蟬']
    subjects = ['語文', '數(shù)學', 'Python']
    scores = [[0 for _ in range(3)] for _ in range(5)]
    for row, name in enumerate(names):
        print('輸入%s的成績' % name)
        for col, subject in enumerate(subjects):
            score = input('%s：' % subject)
            scores[row][col] = score
    print(scores)

30個人茬暇，15個基督徒，15個非基督徒寡喝，30個人圍成圈糙俗，從1個位置開始報數(shù)，數(shù)到9的人不能存活预鬓，最后只能存活15個人巧骚，且都是基督教人，求這30個人的站位

def people_pos():
    people = [True] * 30  # 生成一個列表格二，代表活著的30個人
    counter = 0  # 記錄死去的人的數(shù)目
    index = 0  # 人在列表中的位置（下標）
    number = 0  # 記錄報的數(shù)
    while counter < 15:
        if people[index]:  # 如果這個人活著
            number += 1  # 報數(shù)加1
        if number == 9:  # 如果報數(shù)到9
            people[index] = False  # 把報數(shù)9的這個人設(shè)置為死亡狀態(tài)
            number = 0  # 接著往下數(shù)劈彪，但要重新開始報數(shù)
        index += 1  # 每執(zhí)行一次循環(huán)，下標往后移1顶猜，判斷下一個人是否活著
        index %= 30  # 當下標移動到到29后沧奴，全部人已數(shù)過一遍，所以在index=30時长窄，應該又從第一個人開始數(shù)滔吠，使index的值為0

# 設(shè)計一個函數(shù)傳入年远寸，月，日屠凶，返回這一天是這一年的第幾天

def is_leap_year(year):
    return year % 4 == 0 and year % 100 != 0 or year % 400 == 0


def which_day(year, month, date):
    """
    傳入一個年月日，計算這一天是這一年的第幾天

    :param year: 年

    :param month: 月

    :param date: 日

    :return: 這一天是這一年的第幾天
    """
    days_of_month = [
        [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    ][is_leap_year(year)]
    # [is_leap(year)]代表下標肆资，是一個布爾值
    # 若[is_leap(year)]為真矗愧，則返回一個1，days_of_month = days_of_month[1]
    # 若[is_leap(year)]為假郑原，則返回一個0唉韭，days_of_month = days_of_month[0]
    total = 0
    for mon in range(month - 1):  # 若month = 1，則month - 1 = 0犯犁，循環(huán)不會執(zhí)行
        total += days_of_month[mon]
    return total + date

傳入n属愤，生成n行的楊輝三角

# 1
# 1 1
# 1 2 1
# 1 3 3 1
# 1 4 6 4 1
def pascal_triangle(n):
    triangle = []
    t = [1]
    for row in range(1, n + 1):
        new_t = [1] * row
        for col in range(1, row):
            t.append(0)
            new_t[col] = t[col] + t[col - 1]
        t = new_t[:]
        triangle.append(new_t)
    return triangle


def display_triangle(x):
    for row in x:
        for col in row:
            print(col, end=' ')
        print()

設(shè)計一個函數(shù)，生成蛇形數(shù)組

# 1  2  3  4  5
# 16 17 18 19 6
# 15 24 25 20 7
# 14 23 22 21 8
# 13 12 11 10 9
def ring_figure(n):
    r = [[1] * n for _ in range(1, 6)]  # 生成1個n行n列的列表
    x = n  # 計數(shù)
    time = 1  # 循環(huán)次數(shù)
    start_num = 1  # 循環(huán)開始時的數(shù)字
    row_right = 0  # 行的索引
    row_left = n - 1  # 行的索引
    col_down = n - 1  # 列的索引
    col_up = 0  # 列的索引
    running = True    
    while running :
        if (time - 1) % 4 == 0:  # 向右加數(shù)字
            num1 = row_right     # 此行的列下標
            for num2 in range(start_num, x + 1):
                r[row_right][num1] = num2
                num1 += 1
            row_right += 1
        elif (time - 2) % 4 == 0:  # 向下加數(shù)字
            num3 = row_right   # 此列的行坐標
            for num4 in range(start_num, x + 1):
                r[num3][col_down] = num4
                num3 += 1
            col_down -= 1
        elif (time - 3) % 4 == 0:  # 向左加數(shù)字
            num5 = col_down  # 此行的列坐標
            for num6 in range(start_num, x + 1):
                r[row_left][num5] = num6
                num5 -= 1
            row_left -= 1
        elif (time - 4) % 4 == 0:  # 向上加數(shù)字
            num7 = row_left  # 此列的行坐標
            for num8 in range(start_num, x + 1):
                r[num7][col_up] = num8
                num7 -= 1
            col_up += 1
        time += 1
        start_num = x + 1
        x += n - time // 2
        if n - time // 2 == 0:
            running = False
    return r


def display_ring(x):
    for row in x:
        for col in row:
            str_col = str(col)
            print(str_col.center(6, ' '), end=' ')
        print()

tuple

元組也是一種有序集合酸役，他和列表非常相似，但和列表最大的不同在于：元組是不可變的涣澡，即元組一旦初始化就不能修改，所以沒有插入奄薇、刪除等操作。
元組在時間和空間上都優(yōu)于列表抗愁，所以能使用元組就不使用列表馁蒂。

• 定義tuple

元組是用()表示

t1 = （1蜘腌， 3， 5逢捺，[2, 5, 7]）

注意：元組中的元素一旦被初始化就不能修改谁鳍，但元組中的列表內(nèi)的值可以修改。

• 陷阱

定義一個空元組劫瞳，可直接寫做：

t = ()

定義一個只有1個元素的元組
易錯寫格式：

t = (1)

t =(1)定義的不是tuple志于，是1這個數(shù)！這是因為括號()既可以表示tuple伺绽，又可以表示數(shù)學公式中的小括號嗜湃，這就產(chǎn)生了歧義澜掩，因此，Python規(guī)定刚陡，這種情況下株汉，按小括號進行計算，計算結(jié)果自然是1蝙云。
正確格式：

t = (1,)

Python在顯示只有1個元素的tuple時路召，也會加一個逗號，以免你誤解成數(shù)學計算意義上的括號朵你。

set

set是一個沒有序列的集合揣非，并且會自動過濾相同的元素早敬，所以集合中的元素都是唯一的。

• 定義set

集合用{}表示

set1 = {1, 1, 2, 3, 4, 5, 5}
set2 = {1, 3, 5, 9, 10}

• set可進行的操作

在集合內(nèi)加入元素：

set1.add(6)

交集：取set1 和 set2相同的部分

set3 = set1 & set2
set3 = set1.intersection(set2)

并集：取set1 和 set2 所有元素

set3 = set1 | set2
set3 = set1.union(set2)

差集：set1中去除set1和set2相同的元素

set3 = set1 - set2
set3 = set1.difference(set2)

對稱差：set1去掉set1 和 set2 相同的元素水孩，set2 去掉set1 和 set2 相同的元素

set3 = set1 ^ set2
set3 = set1.symmetric_difference(set2)

遍歷

for val in set2:
    print(val)

隨機刪除琐驴，計算機內(nèi)部有一套刪除機制

set2.pop()

刪除某個元素：若元素不存在，程序會報錯绝淡，所以先判斷元素是否在集合內(nèi)

if 2 in set2:
   set2.remove(2)

判斷set2 是否是 set1 的子集

print(set2 <= set1)
print(set2.issubset(set1))

判斷set1 是否是 set2 的超集

print(set1 >= set2)
print(set1.issuperset(set2))

列表變集合

list1 = [1, 2, 3, 1, 2, 4]
set1 = set(list1)

dict

字典沒有索引牢酵，使用鍵 - 值（key - value）方式存儲，一個鍵對應一個值馍乙，所以查找速度極快，但占用空間較大撑瞧。

• 定義dict

字典用{}表示预伺，一個key對應一個value

dict1 = {'name': '李民', 'age': '19', 'gender': True}

• dict的操作

用key找value

dict1['name']

修改值：通過key找到value，進行修改扭屁。由于一個key只能對應一個value料滥，所以多次對一個key放入value艾船，后面的值會把前面的值覆蓋掉。如果key不存在践宴，程序會報錯爷怀，使用要先判斷key是否在字典中。

if name in diat1:
   dict1['name'] = 李安

更新：增加新的key和對應的value

dict1.update(height=170, fav=['吃', '喝'])  # height 和fav為key烤惊，后面是對應的值

刪除字典：把dict1 和引用斷開了

del dict1

刪除鍵和對應的值

del dict1['name']
dict1.pop('name')

刪除最后一對鍵值

dict1.popitem()

給鍵設(shè)置默認值

dict1.setdefault('age', '20')

更新（給字典增加新的鍵值對）

dict2 = {'name': 'lvping'}
dict1.update(dict2)
dict1.update({''})

遍歷：
1.遍歷鍵：兩種方式

    for x in dict1:
        print(x, '--->', dict1[x]) 

 for x in dict1.keys():
        print(x, '--->', dict1[x]) 

2.遍歷值
用values()函數(shù)吁朦，可直接遍歷字典的中值

 for y in dict1.values():
        print(y) 

實例：把字典的鍵和值顛倒

def main():
    d1 = {'firstname': 'Lv', 'lastname': 'Ping', 'tel': 13322222222}
    d2 = {}
    for key in d1:
        new_key = str(d1[key])
        new_value = key
        d2.update({new_key: new_value})
    d1 = d2
    print(d1)


if __name__ == '__main__':
    main()