题目


  
在以下这个20×20的网格中，四个处于同一对角线上的相邻数字用粗体标了出来： 

  这四个数字的乘积是：26×63×78×14=1788696. 

  在这个20×20网格中，处于任何方向上（上，下，左，右或者对角线）的四个相邻数字的乘积的最大值是多少？


08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 

49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 

81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 

52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 

22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 

24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 

32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 

67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 

24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 

21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 

78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 

16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 

86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 

19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 

04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 

88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 

04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 

20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 

20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 

01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48



解题方法

一共有4个方向的连线，横（—），竖（|），左对角线（\），右对角线（/）。 

依次计算四个方向的最大值，取最大值。

程序

编程的时候需要注意一点，上面的20×20的网格中，为了美观，所有的数字都是两位的，不足两位前面补0。但是这带来一个问题，编程语言中以0开始的直接数表示这个数是八进制表示的。如012=10，但是08是非法的八进制数。因为八进制只有0~7这8个数。所以，在输入数据时要注意这点。顺便一提，以0x开始的数是十六进制数，如0x12=18。

public static void solve() {
    int[][] num = { { 8, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 8 },
            { 49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00 },
            { 81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65 },
            { 52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91 },
            { 22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80 },
            { 24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50 },
            { 32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70 },
            { 67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21 },
            { 24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72 },
            { 21, 36, 23, 9, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95 },
            { 78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 9, 53, 56, 92 },
            { 16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57 },
            { 86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58 },
            { 19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40 },
            { 04, 52, 8, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66 },
            { 88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69 },
            { 04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36 },
            { 20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16 },
            { 20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54 },
            { 01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48 } };
    int max = 0;
    // 横向，从左到右
    for (int i = 0; i < 20; i++) {
        for (int j = 0; j < 17; j++) {
            int multi = 1;
            for (int k = 0; k < 4; k++) {
                multi *= num[i][j + k];
            }
            max = multi > max ? multi : max;
        }
    }
    // 竖向，从上到下
    for (int i = 0; i < 17; i++) {
        for (int j = 0; j < 20; j++) {
            int multi = 1;
            for (int k = 0; k < 4; k++) {
                multi *= num[i + k][j];
            }
            max = multi > max ? multi : max;
        }
    }
    // 右对角线，从左下到右上
    for (int i = 3; i < 20; i++) {
        for (int j = 0; j < 17; j++) {
            int multi = 1;
            for (int k = 0; k < 4; k++) {
                multi *= num[i - k][j + k];
            }
            max = multi > max ? multi : max;
        }
    }
    // 左对角线，从左上到右下
    for (int i = 0; i < 17; i++) {
        for (int j = 0; j < 17; j++) {
            int multi = 1;
            for (int k = 0; k < 4; k++) {
                multi *= num[i + k][j + k];
            }
            max = multi > max ? multi : max;
        }
    }
    // 输出最大值
    System.out.println(max);
}

在以下这个2020的网格中，四个处于同一对角线上的相邻数字用红色标了出来：

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08

49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00

81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65

52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91

22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80

24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50

32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70

67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21

24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72

21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95

78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92

16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57

86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58

19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40

04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66

88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69

04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36

20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16

20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54

01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

这四个数字的乘积是：26  63  78  14
 = 1788696.

在这个2020网格中，处于任何方向上（上，下，左，右或者对角线）的四个相邻数字的乘积的最大值是多少？

public class Test {
	//从左到右计算最大值
	public static long leftToRight(int arr[][]){
		int max = 0;
		int value = 1;
		for(int i = 0; i < 20; i ++){
			for(int j = 0 ;j < 17 ; j++){
				value = arr[i][j] * arr[i][j+1] * arr[i][j+2] * arr[i][j+3];
				if(value > max) max = value;
			}
			
		}
		return max;
	}
	//从上到下计算最大值
	public static long upToDown(int arr[][]){
		int max = 0;
		int value = 1;
		for(int i = 0; i < 17; i ++){
			for(int j = 0 ;j < 20 ; j++){
				value = arr[i][j] * arr[i+1][j] * arr[i+2][j] * arr[i+3][j];
				if(value > max) max = value;
			}
			
		}
		return max;
		
	}
	//从左上到右下计算最大值
	public static long left_uToRight_d(int arr[][]){
		int max = 0;
		int value = 1;
		for(int i = 0; i < 17; i ++){
			for(int j = 0;j < 17 ; j++){
				value = arr[i][j] * arr[i+1][j+1] * arr[i+2][j+2] * arr[i+3][j+3];
				if(value > max) max = value;
			}
			
		}
		return max;
	}
	//从右上到左下计算最大值
	public static long right_uToLeft_d(int arr[][]){
		int max = 0;
		int value = 1;
		for(int i = 3; i < 20; i ++){
			for(int j = 0 ;j < 17 ; j++){
				value = arr[i][j] * arr[i-1][j+1] * arr[i-2][j+2] * arr[i-3][j+3];
				if(value > max) max = value;
			}
			
		}
		return max;
	}
	public static void main(String[] args) {
		/* 构建20*20整数数组 */
		int arr[][] = {{8,2,22,97,38,15,0,40,0,75,4,5,7,78,52,12,50,77,91,8},  
					  {49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,4,56,62,0},  
					  {81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,3,49,13,36,65},  
					  {52,70,95,23,4,60,11,42,69,24,68,56,1,32,56,71,37,2,36,91},  
					  {22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80},  
					  {24,47,32,60,99,3,45,2,44,75,33,53,78,36,84,20,35,17,12,50},  
					  {32,98,81,28,64,23,67,10,26,38,40,67,59,54,70,66,18,38,64,70},  
				  	  {67,26,20,68,02,62,12,20,95,63,94,39,63,8,40,91,66,49,94,21},  
					  {24,55,58,5,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72},  
					  {21,36,23,9,75,0,76,44,20,45,35,14,0,61,33,97,34,31,33,95},  
				      {78,17,53,28,22,75,31,67,15,94,3,80,4,62,16,14,9,53,56,92},  
					  {16,39,5,42,96,35,31,47,55,58,88,24,0,17,54,24,36,29,85,57},  
					  {86,56,0,48,35,71,89,7,5,44,44,37,44,60,21,58,51,54,17,58},  
					  {19,80,81,68,5,94,47,69,28,73,92,13,86,52,17,77,4,89,55,40},  
					  {4,52,8,83,97,35,99,16,7,97,57,32,16,26,26,79,33,27,98,66},  
					  {88,36,68,87,57,62,20,72,3,46,33,67,46,55,12,32,63,93,53,69},  
					  {4,42,16,73,38,25,39,11,24,94,72,18,8,46,29,32,40,62,76,36},  
					  {20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,4,36,16},  
					  {20,73,35,29,78,31,90,1,74,31,49,71,48,86,81,16,23,57,5,54},  
					  {1,70,54,71,83,51,54,69,16,92,33,48,61,43,52,1,89,19,67,48},  
	};  
		System.out.println("max :" + max(leftToRight(arr),upToDown(arr),left_uToRight_d(arr),right_uToLeft_d(arr)));
	}
	private static long max(long a, long b,
			long c, long d) {
		long max = a;
		if(b > max) max = b;
		if(c > max) max = c;
		if(d > max) max = d;
		return max;
	}
	
}

这是一个稍微有难度的题目，容易让人漏掉某种情况，我们先来看一下题目：


在以下这个2020的网格中，四个处于同一对角线上的相邻数字用红色标了出来：

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08

49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00

81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65

52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91

22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80

24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50

32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70

67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21

24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72

21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95

78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92

16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57

86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58

19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40

04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66

88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69

04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36

20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16

20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54

01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

这四个数字的乘积是：26  63  78  14
 = 1788696.

在这个2020网格中，处于任何方向上（上，下，左，右或者对角线）的四个相邻数字的乘积的最大值是多少？
这里最后一行的（上，下，左，右或者对角线）给你提供了思路，上下是一样的，左右也是一样的，但是对角线却又两条"左上--->右下“，”右上--->左下“。这两种情况是不一样的。我们通常都忘记了最后一种情况，导致最后做错，反正我刚开始就是这么做错的。
好，我们来看一下程序：
思路很简单，就是把20X20的放在一个二维数组中，然后分为四种情况分别进行运算就好了。

use strict;
use warnings;

my $big=0;
my $i;
my $j;
my $sum;
my @num=(
["08","02","22","97","38","15","00","40","00","75","04","05","07","78","52","12","50","77","91","08"],
["49","49","99","40","17","81","18","57","60","87","17","40","98","43","69","48","04","56","62","00"],
["81","49","31","73","55","79","14","29","93","71","40","67","53","88","30","03","49","13","36","65"],
["52","70","95","23","04","60","11","42","69","24","68","56","01","32","56","71","37","02","36","91"],
["22","31","16","71","51","67","63","89","41","92","36","54","22","40","40","28","66","33","13","80"],
["24","47","32","60","99","03","45","02","44","75","33","53","78","36","84","20","35","17","12","50"],
["32","98","81","28","64","23","67","10","26","38","40","67","59","54","70","66","18","38","64","70"],
["67","26","20","68","02","62","12","20","95","63","94","39","63","08","40","91","66","49","94","21"],
["24","55","58","05","66","73","99","26","97","17","78","78","96","83","14","88","34","89","63","72"],
["21","36","23","09","75","00","76","44","20","45","35","14","00","61","33","97","34","31","33","95"],
["78","17","53","28","22","75","31","67","15","94","03","80","04","62","16","14","09","53","56","92"],
["16","39","05","42","96","35","31","47","55","58","88","24","00","17","54","24","36","29","85","57"],
["86","56","00","48","35","71","89","07","05","44","44","37","44","60","21","58","51","54","17","58"],
["19","80","81","68","05","94","47","69","28","73","92","13","86","52","17","77","04","89","55","40"],
["04","52","08","83","97","35","99","16","07","97","57","32","16","26","26","79","33","27","98","66"],
["88","36","68","87","57","62","20","72","03","46","33","67","46","55","12","32","63","93","53","69"],
["04","42","16","73","38","25","39","11","24","94","72","18","08","46","29","32","40","62","76","36"],
["20","69","36","41","72","30","23","88","34","62","99","69","82","67","59","85","74","04","36","16"],
["20","73","35","29","78","31","90","01","74","31","49","71","48","86","81","16","23","57","05","54"],
["01","70","54","71","83","51","54","69","16","92","33","48","61","43","52","01","89","19","67","48"],
);
#第一种情况，左---->右
for($i=0;$i<16;$i++)
{
	for($j=0;$j<16;$j++)
	{
		$sum = $num[$i][$j]*$num[$i][$j+1]*$num[$i][$j+2]*$num[$i][$j+3];
		if($sum>$big)
		{
			$big=$sum;
		}
		else
		{
			next;
		}
	}
}
print "$big\n";


#第二种情况，上--->下
$big=0;
for($i=0;$i<16;$i++)
{
	for($j=0;$j<16;$j++)
	{
		$sum = $num[$i][$j]*$num[$i+1][$j]*$num[$i+2][$j]*$num[$i+3][$j];
		if($sum>$big)
		{
			$big=$sum;
		}
		else
		{
			next;
		}
	}
}
print "$big\n";

#第三种情况，左上--->右下
$big=0;
for($i=0;$i<16;$i++)
{
	for($j=0;$j<16;$j++)
	{
		$sum = $num[$i][$j]*$num[$i+1][$j+1]*$num[$i+2][$j+2]*$num[$i+3][$j+3];
		if($sum>$big)
		{
			$big=$sum;
		}
		else
		{
			next;
		}
	}
}
print "$big\n";

#第四种情况，右上--->左下
$big=0;
for($i=4;$i<20;$i++)
{
	for($j=1;$j<16;$j++)
	{
		$sum = $num[$i][$j]*$num[$i-1][$j+1]*$num[$i-2][$j+2]*$num[$i-3][$j+3];
		if($sum>$big)
		{
			$big=$sum;
		}
		else
		{
			next;
		}
	}
}
print "$big\n";




得到四个结果，我们看看就知道大小了
结果如下：

C:\WINDOWS\system32\cmd.exe /c perl "F:\perl\c.pl"
48477312
51267216
32719995
70600674
Hit any key to close this window...

Python学习（四）
一、列表
1、列表的定义
2、列表的常见操作
3、区分关键字、函数、方法
二、元组
1.元组的定义
2、元组的基本操作
3、元组的使用场景
4、列表和元组之间的转换
三、字典
1、定义
2、基本用法
3、应用的场景
四、字符串
1、定义
2、字符串基本操作
1、类型判断
2、查找替换
3、大小写转换
4、文本对齐
5、去除空白字符
6、拆分和连接
3、字符串切片
五、公共方法
1、Python内置函数
2、切片
3、运算符
4、for break
六、小技巧
1、字符串判断
2、pass
3、TODO注释
4、改变变量名
5、Linux上Shebang符号（#!）


知识回顾：

（1）、Python中变量分为数字型和非数字型

数字型：int.float,bool,complex

非数字型：字符串、列表、元组、字典

（2）、在Python中，所有的非数字型变量都有以下的特点：


都是一个序列，可以理解为容器
取值：[]
遍历：for in
计算长度，最大值，最小值，比较，删除
连接：+ 和 重复：
切片

一、列表
1、列表的定义
列表变量名 = [内容，中间用逗号，同一个列表可以储存不同类型的数据]

2、列表的常见操作
name_list = ["zhangsan","lisi"]

#取值
print(name_list[0])

#取索引
print(name_list.index("lisi"))

#修改
name_list[0] = "wangwu"

#增加值
#append函数向末尾增加
name_list.append("zhangsan")
#insert函数向指定位置增加
name_list.insert(0,"wangmazi")
#extend函数将另一个列表的值完全加入
tmp_list = ["tangseng","sunwukong"]
name_list.extend(tmp_list)
print(name_list)

#删除数据
#remove方法删除确定的值
name_list.remove("tangseng")
#clear方法删除列表中的所有值
name_list.clear()
#pop方法在默认的时候删除列表中最后一个元素，有参数的时候删除指定索引的值并且返回该值
name_list.pop()
name_list.pop(0)
#使用del关键字,删除指定的数据
#del关键字的本质是将数据从内存中删除，一般不建议使用
del name_list[0]

#列表 统计(函数)
#len可以统计列表中元素的个数
l = len(name_list)
#count方法可以统计某一个数据在列表中出现的次数
c = name_list.count("lisi")

#列表排序
num_list = [6,8,4,1,10]
#升序排序
num_list.sort()
name_list.sort()
#降序
num_list.sort(reverse=True)
#逆序反转
num_list.reverse()

#循环遍历列表
for name in name_list:
    print(name,end=" ")
    

列表的循环遍历：

语法：
for 循环内部使用的变量 in 列表

for in是在Python中为了提高列表的遍历效率，专门提供的迭代iterator遍历。

与C、Java等语言相同，在使用遍历器遍历的过程中不能进行删除，否则会导致结果不正确，例如下面所示：
#方法一
num_list = [1,90,80,8,9,2]
#删除10以内的数
for num in num_list:
    if num>=0 and num<=10:
        num_list.remove(num)

print(num_list)

#方法二
tmp_list = [1,90,80,8,9,2]
result = []    #注意Python中变量申明的同时必须赋值，才会创建该变量
for num in tmp_list:
    if num>=0 and num<=10:
        result.append(num)
print(result)

for num in result:
    tmp_list.remove(num)
print(tmp_list)

结果：



结果分析：

使用方法一，在遍历的过程中删除，应该是导致了迭代器的混乱，所以不能直接删除。

正确的打开方式应该是将需要删除的数据先存到一个列表中，然后再进行删除！
列表操作方法总结：


3、区分关键字、函数、方法
（1）、关键字：是Python内置的，具有特殊意义的标识符，查看Python的关键字的方法为：
import keyword
print(keyword.kwlist)
#关键字使用的后面不需要使用括号

（2）、函数封装了独立的功能，可以直接调用。
函数名（参数）

（3）、方法

方法和函数类似，同样是封装了独立的功能。

方法需要通过对象来调用，表示针对这个对象要做的操作。
对象.方法名（参数）

二、元组
1.元组的定义
定义：

（1）、用于储存一串信息，数据之间用逗号隔开

（2）、元组用（）定义

（3）、元组的索引从0开始

（4）、元素不能修改

创建空的元组

name = （）


元组中只包含一个元素的时候，需要在后面加上逗号

name = (5,)

2、元组的基本操作
info_tuple = ("zhangsan",18,1.75)

#取值和取索引
print(info_tuple[0])
print(info_tuple.index("zhangsan"))

#count统计一个数据再元组中出现的次数
print(info_tuple.count("zhangsan"))
#len函数统计元组中数据的个数
print(len(info_tuple))

#循环遍历
for my_info in info_tuple:
    print(my_info)

注意：虽然元素可以for in遍历，但是因为元组可以有很多类型的数据，所以在格式化输出的时候比较复杂，因此很少使用。
3、元组的使用场景
（1）、函数的参数和返回值

（2）、格式字符串，在print函数的格式化输出的时候括号的参数就是一个元组
print("%s 的年龄是 %d 身高是 %.2f" % ("肖战",28,1.83))
tmp_str = "%s 的年龄是 %d 身高是 %.2f" % ("肖战",28,1.83)
print(tmp_str)

（3）、让列表不可以被修改，以保护数据安全
4、列表和元组之间的转换
why:

如果希望列表被保护，不被修改
操作：
#列表变为元组
tuple(列表)

#元组变为列表
list(元组)

三、字典
1、定义
（1）、字典是除列表之外Python之中最灵活的数据类型

（2）、字典可以用来存储多个数据，通常用于存储描述一个物体的相关信息

（3）、和列表的区别：列表是有序的，字典是无序的，也就是说使用Print进行输出的时候可能与定义的顺序是不同的，但是好像Python3.7以上顺序是固定的

（4）、字典使用{}进行定义

（5）、字典是键值对：

键key是索引

值value是值

键和值之间用冒号隔开，不同的对之间都好

键不能重复

值可以是任意的数据类型，但键只能使用字符串、数字或者元组
2、基本用法
xiaoming = {"name":"xiaoming"}

#取值，取值的时候如果key不存在那么就会报错
print(xiaoming["name"])

#增加修改值
#key存在就是修改
#key不存在就是增加
xiaoming["age"] = 18
xiaoming["name"] = "xm"

#删除,删除指定的key
#如果key不存在，那么会报错
xiaoming.pop("name")

#统计键值对的数量
print(len(xiaoming))

#合并键值对
#如果被合并的字典中有相同的键值对，那么会覆盖原来的键值对，update么
tmp = {"name":"xiaoming"}
xiaoming.update(tmp)

#清除
xiaoming.clear()
print(xiaoming)

#循环遍历
for k in xiaoming:
    print(xiaoming[k])


3、应用的场景
（1）、使用字典存储一个物体的全部信息

（2）、将多个字典组合成一个列表使用

例如：
info_list = [{"name":"xiaoming",
"num":1,
"age":18},
{"name":"lisi",
"num":2,
"age":19},
]
for person in info_list:
    print(person)

四、字符串
1、定义
可以使用单引号和双引号，但是如果字符串内容有单引号，那么用双引号定义；如果字符串内容有双引号，那么用单引号定义。
2、字符串基本操作
1、类型判断

2、查找替换

3、大小写转换

4、文本对齐

5、去除空白字符

6、拆分和连接
常见方法：
hello_str = "hello python"

#统计字符长度
len(hello_str)

#统计某个字符串出现的次数
hello_str.count("llo")

#子串出现的位置
#如果该子串没有出现，那么就会报错
hello_str.index("llo")

#判断字符只由空格和空白字符（\n,\t,\r)
tmp = "  \n\t\r"
tmp.isspace() #输出True

#判断字符串中是否值包含数字，但是都不能判断小数
num_str = "1"

print(num_str.isdecimal())
print(num_str.isdigit())
print(num_str.isnumeric())

#判断字符串是否以指定字符串开头
hello_str.startswith("hello")

#判断字符串的结束
hello_str.endswith("python")

#查找指定字符串，返回索引
#两者之间的区别是，index如果指定字符串不存在那么报错，find返回-1
hello_str.find("llo")
hello_str.index("llo")

#替换字符串
#replace(被替换，替换)
#replace执行之后会返回一个新的字符串，但是不会修改原字符串的内容
hello_str.replace("python","world")




空白字符：

\n,\t,\r(回车)

3、字符串切片
切片方法适用于字符串、列表、元组，这三个都是有序的，都可以通过下标取值。
切片的方法：

字符串[开始索引：结束索引：步长]

需要注意的一点是，Python中字符串下标为-1代表的是最后的一个字符,-2代表的是倒数第二个字符

步长是从当前字符开始计算的，也就是本身这个字符也是在计算范围内的
注意：

（1）、索引的范围是左闭右开

（2）、从头开始，开始索引数字可以省略，冒号不能省略

（3）、到末尾结束，结束索引数字可以省略，冒号不能省略

（4）、步长默认为1，如果连续切片，数字和冒号都可以省略
例子：
num_str = "0123456789"
 
 #输出所有的偶数
print(num_str[::2])


 #输出所有的奇数
print(num_str[1::2])

 #使用切片的方法将字符串倒序
 #注意这里的就表示倒序，然后-1表示向左切片
print(num_str[-1::-1])
print(num_str[::-1])  #is ok

五、公共方法
1、Python内置函数
内置函数就是不需要导入工具包可以直接使用的，Python的内置函数有：

del有两种使用方式：

（1）、通过关键字的方式 del data

（2）、函数的方式del(data)
2、切片
字典是不能进行切片操作的，因为字典是无序的，是通过键值对进行数据保存的。
3、运算符
小知识：

append函数会将添加的东西视为一个。

当我们需要查看可以使用的方法的时候，可以使用tab键，在终端中查看。
4、for break
what:

在for in遍历的时候，如果是通过break跳出循环的，那么就不执行else中的语句，否则就执行。

使用的场景：

如果希望在搜索列表是，所有的内容检查之后，都没有发现需要搜索的目标，还希望统一得到一个提示的时候使用。

例子：
student = [
    {"id":1,
    "name":"xiaoming"},
    {"id":2,
    "name":"lisi"},
    {"id":3,
    "name":"zhangsan"}
]
finid = 4
for person in student:
    if person["id"] == 4:
        print("find!")
        break
else:
    print("no find")

六、小技巧
1、字符串判断
场景：根据用户输入的数字选择不同的操作。

技巧：

（1）、使用input那么就是字符串，我们并不需要使用int转换用户输入，可以避免一旦用户输入的不是数字，导致程序运行错误

（2）、使用in针对列表判断，而不是使用or

例如：


2、pass
pass就是一个空语句，不做任何事情，一般用做占位符，是为了保持程序结构的完整性。
3、TODO注释
在#使用TODO，用于标记需要去做的工作
4、改变变量名
在VSCODE中如果要改变变量名，鼠标指向变量-》右键-》重命名，可以一次性改变全部。
5、Linux上Shebang符号（#!）
#!这个符号叫做Shebang，通常在Linux系统脚本中的第一行开头使用，指明执行这个脚本文件的解释程序。也就是说可以直接用./*.py执行程序而不是python *.py。
操作：

（1）、使用which查询python3解释器所在路径

（2）、修改要运行的主Python文件，在第一行增加

#! python3解释器的路径

（3）、修改主Python文件的文件权限，增加执行权限

sudo chmod +x main.py

（4）、执行程序

./main.py

不再需要python main.py


开学前辛苦营业的一天