python编程试题入门 python编程题目入门

文章目录

• 前言
• 引入
• 题目合集

• 1.统计不同字符的个数
• 2.求两个整数的最大公约数，最小公倍数
• 3.逆序输出
• 4.进制转换(以十进制转其他进制为例)
• 5.输出三位数中的水仙花数
• 6.素数
• 7.回文数判断
• 8.闰年判断
• 9.公式法计算 π 值
• 10.求一元二次方的根（c语言）
• 11.求某分数数列前20项之和 （C语言）
• 12.累加、阶乘计算
• 13.输出数字对自由组合（C语言）
• 14.斐波那楔数列前n项和
• 15.数组/列表、元组、字典的创建及操作

• Python代码：

• (1)列表
• (2)元组
• (3)字典
• (4)集合

• C语言：

• (1)输入与输出
• (2)二维数组转置:
• (3)二维数组找最小数
• (4)二维数组找鞍点：
• (5)二维数组相乘

• 16.额外补充

• Python

• (1)指定缺省参数的默认值
• (2)多值参数求和
• (3)多值参数_字典与元组的拆包
• (4)使用不定长参数
• (5)时间函数
• (6)文本进度条更新
• (7)try检测
• (8)CSV文件的读写
• (9)田字格的输出

• C语言

• （1）变量类型(按作用域划分)
• （2）结构体
• （3）共用体
• （4）枚举变量

• Python面向对象

• （1）类的声明
• ①常规方法
• ②魔法方法
• （2）类的继承
• （3）类的多态
• (4)迭代器和生成器

• C语言结构化过渡到面向对象

• 
  
• 
  
• 
  
• 
  

前言

随着科学技术的发展、大数据时代信息的更新速度加快，掌握一项基本的编程思维能力和一定的计算机基础成为时代的趋势，因此练习编程成为普遍现象。本文收集了部分的习题及解法，希望对大家有帮助。

提示：这是一个有趣的编程引入题

引入

大家学过Python的话应该知道“天天向上的力量”这个经典的入门编程题，而这道题对博主本人也很有意义，因为这是博主上大学的第一门编程语言讲授课的讲解题目，而刚好这道题也反映出IT行业的一个时刻保持学习状态的特点，在此，博主以这道题为开头、以乔帮主的一句“Stay hungry, stay foolish”与大家共勉

# 一年365天，以第1天的能力为基数，记为1.0，当好好学习时能力值相比前一天提高1%，当没有学习时能力值相比前一天下降1%。问：每天努力和每天放任，一年下来的能力值相差多少
a = pow((1+0.01), 365)
b = pow((1-0.01), 365)
print("天天向上的力量：{:.5f}, 天天向下的力量：{:.5f}".format(a, b))
print("一年下来两者相差：%.10f" % (a-b))
print("================================================================")

# 一年365天，以第1天的能力为基数，记为1.0，当好好学习时能力值相比前一天提高1%，当没有学习时能力值相比前一天下降1%。问：每天努力和每天放任，一年下来的能力值相差多少
a = pow((1+0.01), 365)
b = pow((1-0.01), 365)
print("天天向上的力量：{:.5f}, 天天向下的力量：{:.5f}".format(a, b))
print("一年下来两者相差：%.10f" % (a-b))
print("================================================================")

# 一年365天，一周5个工作日，如果每个工作日都很努力，就可以提高1%，仅在周末放松一下，能力值下降1%，问：效果如何
dayfactor = eval（input("请输入每天努力or放纵的因子:"))
dayup = 1.00
for i in range(365):
        if i % 7 in [6, 0]:
            dayup = dayup * (1 - dayfactor)
        else:
            dayup = dayup * (1 + dayfactor)
print("向上5天向下2天后一年下累积能力值:{:.2f}".format(dayup))
print("================================================================")

# 每周工作5天，休息2天，休息日水平下降0.01，问：工作日要努力到什么程度，一年后的水平才与每天努力1%取得的效果一样呢
def dayUp(df):
    dayup = 1.0
    for i in range(365):
        if i % 7 in [0, 6]:
            dayup = dayup * (1 - 0.01)
        else:
            dayup = dayup * (1 + df)
    return dayup
dayfactor = 0.01
while(dayUp(dayfactor) < 37.78):
    dayfactor += 0.001
print("每天努力的参数是：{:.3f}".format(dayfactor))
print("================================================================")
 
 # 天天向上续。以7天为周期，连续学习3天能力值不变，从第4天开始至第7天每天能力增长为前一天的1%。如果7天中有1天间断学习，则周期从头开始算。请编写程序回答，如果初始能力值为1，连续学习365天后能力值是多少？
dayup = 1
dayfactor = 0.01
i = 362
dayup = pow((dayup + dayfactor), i)
print("坚持365天下来的力量是:{:.3f}".format(dayup))
print("================================================================")

# 天天向上续。采用上题的能力增长模型，如果能力初始值为1，固定每10天休息1天，365天后能力值是多少？如果每15天休息1天呢？
def dayUp(days):
    dayup = 1.0
    dayfactor = 0.01
    i = (365 % 10) - 3
    dayup = pow((dayup + dayfactor), (days - 4) * 36) * pow((dayup + dayfactor), i)
    return dayup
print("当 days=10 时，能力模型的力量是：{}".format(dayUp(10)))
print("当 days=15 时，能力模型的力量是：{}".format(dayUp(15)))
print("================================================================")

提示：部分习题有Python和C两种编程，但有些只有其中之一。解法不唯一，欢迎在评论区交流

题目合集

1.统计不同字符的个数

n = input("请输入一行字符:")
a = b = c = d = 0
for i in n:
    if ord('a')<=ord(i)<=ord('z') or ord('A')<=ord(i)<=ord('Z'):
        a = a + 1
    elif ord('0') <= ord(i) <= ord('9'):
        b = b + 1
    elif ord(i) == ord(' '):
        c = c + 1
    else:
        d = d + 1
print("这一行字符中字母的数量是：{},数字的数量是：{},空格数量是：{},其他字符的数量是：{}。".format(a, b, c, d))

// 按顺序读取键盘上的输入，遇到字符#时停止，并输出空格、字母e和i出现的次数。
#include<stdio.h>
int main()
{
	int num_space, num_e, num_i;
	char a = 0;
	printf("请输入一串字符串：\n");
	for(;;scanf("%c", &a))
	{
		if(a == 35)
			break;
		else if(a == 32)
			num_space++;
		else if(a == 101)
			num_e++;
		else if(a == 105)
			num_i++; 
	}
	printf("空格、字母e和i出现的次数分别为：%d, %d, %d\n", num_space, num_e,num_i);
	
	return 0;
}

2.求两个整数的最大公约数，最小公倍数

# Python:

def get_greatest_common_divisor_V2(a,b):
    big=max(a,b)
    small=min(a,b)
    if big%small==0:
        return small
    return get_greatest_common_divisor_V2(big%small,small)

i = get_greatest_common_divisor_V2(4, 10)
print("两数的最大公约数是：{}".format(i))
print("两数的最小公倍数是：{}".format(4 * 10 / i))

C_code:

#include <stdio.h>
int main()
{
    int a,b,c,e,f,g;
    printf("请输入两个正数:");
    scanf("%d%d",&a,&b);
     e=a;
     f=b;
     c=a%b;
    while(c!=0)
    {
        a=b;
        b=c;
        c=a%b;
    }
    g=e*f/b;
     printf("最大公约数是 %d\n最小公倍数是 %d\n",b,g);
     return 0;
}

3.逆序输出

# Python:

#递归实现字符串翻转
import sys
sys.setrecursionlimit(2000)

def reverse(s):
    if s == '':
        return s
    else:
        return reverse(s[1:]) + s[0]
aa = input("请输入一个字符串：")
print(reverse(aa))

# Python:

# 最小最大数分别放置首尾
data = list(map(eval,input("请输入一组数据，各数之间用英文中的逗号分隔:").split(",")))
print(data)
min_L = data.index(min(data))             #找到最小数据的索引序号
if min_L != 0:
    data[0], data[min_L] = data[min_L], data[0]

max_L = data.index(max(data))
if max_L != len(data)-1:
    data.append(data.pop(max_L))          #先踢出最大值，再将它追加到序列末尾
print(data)

C_code:

/* 反序输出三位数 */
#include<stdio.h>
int main()
{
	int i;
	printf("请输入一个三位数：");
	scanf("%d", &i);
	printf("您所输入的三位数的反序是：\n");
	while(i)
	{
		printf("%d", i%10);
		i /= 10; 
	}
	
	return 0;
}

/* 通过字符指针的传递，执行被调函数，将主函数中字符串的字符逆序存放 */
#include<stdio.h>
int main()
{
	char str[20];
	void sub(char*, int);
	gets(str);
	sub(str, strlen(str));
	puts(str);
	
	return 0;
}

void sub(char*p1, int n)
{
	char *p2=p1+n-1, temp;
	while(p1<p2)
	{
		temp=*p1;
		*p1++=*p2;
		*p2--=temp;
	}
}

4.进制转换(以十进制转其他进制为例)

# Python:

# 十进制转二进制
print("(Into binary)Please type an integer:")
a = int(input())
print(bin(a))

# 十进制转八进制
print("(Into octal)Please type an integer:")
b = int(input())
print(oct(b))

# 十进制转十六进制
print("(Into hexadecimal)Please type an integrate:")
c = int(input())
print(hex(c))

// C:

#include<stdio.h>

void convert(int x, int y)
{
    if(x > 0)
    {
        convert(x/y, y);
        if(y!=16) 
            printf("%d", x % y);
        else 
            printf("%x", x % y);	// 以十六进制输出
    }
}
int main()
{
    int x, y;//输入要转换的数值和转化进制数
	printf("请输入要转换的十进制整数： ");
    scanf("%d", &x);
	printf("请输入要转换的进制： ");
	scanf("%d", &y);
    convert(x,y);

	return 0;
}

5.输出三位数中的水仙花数

题目描述：水仙花数是指一个n位数 (n≥3)，它的每个位上的数字的n次幂之和等于它本身。例如：153是一个“水仙花数”，因为 153 是个 3位数，而13+53+3**3==153。要求输出三位数中的所有水仙花数

for i in range(100,1000):
    a = i // 100                 #百位数
    b = i // 10 % 10
    c = i % 10
    if a**3 + b**3 + c**3 == i:
        print(i)

#include<stdio.h> 
#include<math.h> 

int main()
{
	int i,sum;
	printf("水仙花数有：");
	for(i=100;i<1000;i++)
	{
		sum=(i/100)*(i/100)*(i/100)+(i%100/10)*(i%100/10)*(i%100/10)+(i%100%10)*(i%100%10)*(i%100%10);
		if(i==sum)
		{
		   printf("%d\n",sum);	
		}		
	}
	return 0;
}

6.素数

# 函数调用判断素数

def prime(x):
    t=True
    for i in range(2,x):
        if x % i == 0:
            t = False
            break
    return t
for x in range(200, 1001):
    if prime(x):
        print(x, end=' ')

7.回文数判断

题目描述:
回文数判断。设n是一任意自然数，如果n的各位数字反向排列所得自然数与n相同，则n被称为回文数。从键盘上输入一个5位数字，请编写程序这个数是不是回文数

# 1、字符串判断
x = input("请输入一个整数：")
if x==x[::-1]:
    print("是回文数。")
else:
    print("不是回文数。")
    
# 2、颠倒数据后判断
x = int(input("请输入一个整数："))
if x < 0 or (x % 10 == 0 and x != 0):
    print("不是回文数。")
elif not x // 10:
    print("是回文数。")
else:
    hou = 0
    while (x > hou):
        hou = hou * 10 + x % 10
        x //= 10
    if x == hou or x == (hou // 10):
        print("是回文数。")
    else:
        print("不是回文数。")

8.闰年判断

//输入某年某月某日，判断这一天是这一年的第几天？ 
#include<stdio.h>

//判断闰年函数
int isLeapYear(int year)
{
	//闰年，能被4整除但不能被100整除，或能被400整除 
	if((year%4==0 && year%100!=0) || year%400==0)
	{
		return 1;
	}
	
	return 0;
}

//计算某年某月某日是第几天
int calculateDays(int year,int month,int day)
{
	int i; //循环变量 
	int days=0; //存放总天数 
	//存放平年每个月的天数，有效下标从1开始 
	int days_of_month[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
	 
	for(i=1;i<month;i++)
	{
		days=days+days_of_month[i];//计算包含全部月份的天数 
	}
	days=days+day; //加上不全月份的天数 
	
	//如果是闰年且包含全部2月份 
	if(isLeapYear(year) && month>=3)
	{
		days=days+1; //天数+1，因为2月份多一天 
	}
	
	return days;
}

int main()
{
	int year,month,day;
	printf("请依次输入年，月，日，用空格隔开:\n");
	scanf("%d %d %d",&year,&month,&day);
	printf("这一天是这一年的第%d天",calculateDays(year,month,day));
	
	return 0;
}

9.公式法计算 π 值

sum = 0
i = 1
t = 1  #第i项
while abs(t) > 1e-6:
    t = (-1)**(i+1)/(2*i-1)  #(-1)**(i+1),第i项的符号(分子)
    sum += t
    i += 1
print("{0:.5f}".format(4*sum)) 
print('%.5f' % (4*sum))

from random import random
from math import sqrt
from time import perf_counter
DARTS = 1000
hits = 0.0
start = perf_counter()
for i in range(1, DARTS+1):
    x, y = random(), random()
    dist = sqrt(x ** 2 + y ** 2)
    if dist <= 1.0:
        hits = hits + 1
pi = 4 * (hits / DARTS)
end = perf_counter()
print("pi的值是:{:.2f}".format(pi))
print("运行时间是：{:.5f}s".format(end - start))

//公式法求pi的近似值 
#include<stdio.h>
#include<math.h>
int  main()
{
	int i=0;
	int n=1;
	double sum=1.0, pi=0.0, sign=1;
	while(fabs(sum) >= 1e-6)
	{
		pi+=sum;
		n+=2;
		sign=-sign;
		sum=sign/n;
		i++;
	}
	pi=pi*4;
	printf("pi的值是：%10.8f", pi);
	
	return 0;
}

10.求一元二次方的根（c语言）

//求一元二次方程的根，并考虑 判别式大于0、等于0、小于0的情况
#include<stdio.h>
#include<math.h>
int main()
{
    double a, b, c, x1, x2, d,x3 ,x0;
    printf("输入方程的三个系数:");
    scanf_s("%lf %lf %lf", &a, &b, &c);
    if (a != 0)
    {
        d = sqrt(b * b - 4 * a * c);
        if (d == 0)
        {
            x0 = (-b) / (2 * a);
            printf("%.2lf\n", x0);
        }
        else if(d>0)
        {
            x1 = (-b + d) / (2 * a);
            x2 = (-b - d) / (2 * a);
            printf("%.2lf %.2lf\n", x1, x2);
        }
        else 
            printf("x无解");
    }
    else
    {
        x3 = -c / b;
        printf("%.2lf\n", x3);
    }
    return 0;
}

11.求某分数数列前20项之和 （C语言）

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    double a,b,temp;    //a为分母，b为分子，temp保存前一项的分子
    double sum=0;
    int i;
    a=2;
    b=1;
    for(i=0;i<20;i++)
    {
        sum+=a/b;
        temp=a;     //先保存前一项的分子
        a+=b;      //修改分子
        b=temp;     //修改分母（等于前一项分子)
    }
    printf("Sum is %6.4lf\n",sum);
    return 0;
}

12.累加、阶乘计算

递归实现

# 定义一个函数 sum_numbers
# 能够接收一个 num 的整数参数
# 计算1 + 2 + 3 ...... + num的结果

def sum_numbers(num):
    if num == 1:
        return 1


    temp = sum_numbers(num - 1)
    return num + temp

result = sum_numbers(1)
print(result)

//定义函数运用递归计算n的阶乘
#include<stdio.h>
int main()
{
	int fun(int);
	int n;
	printf("请输入数值：");
	scanf("%d", &n);
	if(n<0)
		printf("输入错误！请重新输入");
	else
		printf("%d! = %d", n, fun(n)); 
	
	return 0;
} 
int fun(int n)
{
	if(n<=1)
		return 1;
	else
		return n*fun(n-1);
}

一般算法

// 用循环求1!+2!+3!+…+10!
#include<stdio.h>
#include<math.h>
int main()
{
	int i;
	int j;
	int sum=0;
	for(i=1;i<=10;i++)
	{
		j*=i;
		sum+=j;
	} 
	printf("1!+2!+3!+…+10!的和为：%d", sum);
	return 0;
}

// 调用静态局部变量，计算5以内各数的阶乘
#include<stdio.h>
int main()
{
	int fact(int);
	int i;
	for(i=1;i<6;i++)
		printf("%d! = %d\n", i, fact(i));
	
	return 0;
} 
int fact(int n)
{
	static int f=1;
	f=f*n;
	return f;
}

13.输出数字对自由组合（C语言）

//输出所有由数字“1”“2”“3”组成的三位数 
#include<stdio.h>
int main()
{
	int i, j, k;
	printf("由数字1、2、3组成的三位数是：\n");
	for(i = 1;i <= 3;i++)
	{
		j = 1;
		while(j <= 3)
		{
			k = 1;
			do
			{
				if(i != k && i != j && j != k)
				{
					printf("%d%d%d ", i, j, k); 
				}
				
			k++;
			}while(k <= 3);	
			j++;
		}
	}
	
	return 0;
}

补充：Python随机选取某序列中的元素

import random
veg=['apple','pear','peach','orange','fish','苹果']
print(random.choice(veg))

14.斐波那楔数列前n项和

"""列表输出斐波那楔数列"""

f = [1, 1]
sum = 2
n = eval（input("请输入项数n: "))
for i in range(2, n+1):
    f.append(f[i-1] + f[i-2])
    sum += f[i-1] + f[i-2]
print("%d项的斐波那楔数列为:" % (n+1), f)
print("\n该数列的前%d项和为:   %d" % (n+1, sum))

//求斐波那楔数列前n项和 
//输入n，输入前n项，以及前n项和//
#include <stdio.h>
int main()
{
	int n, i, t;
	int sum = 0, flag = 2;         //flag为换行标记
	int a1 = 1, a2 = 1;           //前两项先列出来
	printf("请输入所需要的项数：");
	scanf("%d", &n);
	printf("%d %d ", a1, a2);
	for (i = 3; i <= n; i++)      //从第三项开始
	{
		t = a1 + a2;
		printf("%d ", t);
		sum = sum + t;            
		a1 = a2;                  //注意这里的写法，赋值，产生新的a1、a2
		a2 = t;
		flag++;
		if (flag % 5 == 0)      //原本想每5个输出一行，但是我之前先输出了a1、a2
			printf("\n");         //导致第一行有7个，并不能完成每5行输出的任务
		                          //放在这里让大家解决，感觉会麻烦一点
	}
	printf("\n\n前%d项和为:%d\n", n, sum+2);   //注意这里的sum需要加上初值的2
	return 0;
}

15.数组/列表、元组、字典的创建及操作

Python代码：

提示：此仅包括一维和二维，DL中涉及三维到四维的张量，详见Jupyter

(1)列表

①一维数组的基本操作

#列表可定义不同类型的数据，并且索引值是从0开始计数
name_list =['hello python','larissa','Alex',520,True]
#1取值与取索引
print(name_list[2])
print(name_list.index(520))
#2修改 or 替换 列表中的数据
"""
name_list[0] = "hello world"
print(name_list)

"""
#3增加
"""append 是在列表最后增添数据
   insert 是在列表的指定位置插入数据
   extend 用于在某一列表后拼接另一列表"""
"""name_list.append('1')
print(name_list)
print(len(name_list))

name_list.insert(2,'1')
print(name_list)
print(len(name_list))

another_list = ['1','2','3']
name_list.extend(another_list)
print(name_list)"""
#4删除
"""remove 可删除列表中指定数据
   pop 在不传递数据的索引之前默认删除列表最后一个数据，在传递索引值后可删除索引值对应的数据
   clear 可以清空列表的所有数据
   del关键字本质上是将一个变量从内存中删除"""
"""name_list.remove(520)
print(name_list)

name_list.pop(2)
print(name_list)

name_list.clear()
print(name_list)

str = "nihao"
del str
print(str)"""
#5统计
"""len可统计列表中元素的个数
   count可统计某一数据出现的次数"""
"""print(len(name_list))
name_list.append(520)
print(name_list.count(520))"""
#6排序
"""sort()升序
   sort(reverse=True)降序
   reverse()逆序/反序"""
str_list = ["wangwu","lisi","zhangsan"]
num_list = [1,3,9,5]
"""str_list.sort()
   num_list.sort(reverse=True)
   num_list.reverse()
   print(num_list)"""

②二维数组的创建及基本操作

"""创建二维数组"""

#1.一维复制法
a = [[]] * 3
a[0].append(1)
a[1].append(2)
a[2].append(3)
print(id(a[0]))
print(id(a[1]))
print(a)
b = [[] for i in range(3)]
b[0].append(1)
b[1].append(2)
b[2].append(3)
print(id(b[0]))
print(id(b[1]))
print(b)
#2.直接创建法
a1 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
print(a1)
#3.numpy库调用
import numpy as np
a2 = np.zeros((3, 3))
print(a2)

# 列表推导式： 
# #         [表达式 for 变量 in 列表]
# #         [out_exp_res for out_exp in input_list]
names = ["Alex", "Bob", "Clara", "Davie", "Eve"]
new = [name.upper() for name in names if len(names) > 3]
print(new)
# #0-100 中可以被2整除的数作为一个列表
num = [i for i in range(100) if i % 2 == 0]
print(num)

# 遍历列表
s2 = ['name', 'num', 'score']
s3 = ['Alex', 1001, 91.5]
for index, val in enumerate(s2):
    print(index, '(index)', val, '(value)')
for i, j in zip(s2, s3):
    print(i, '->', j)

(2)元组

①基本操作

#元组不可修改
info_tuple = ("zhangsan",54,"wangwu","wangwu")
print(type(info_tuple))

#01取值与取索引
print(info_tuple[1])
print(info_tuple.index("zhangsan"))

#02计算某个数据出现的次数
print(info_tuple.count("wangwu"))

②拓展操作

# 元组只包含一个元素时，需要在元素后面添加一个逗号，否则括号会被当做运算符使用
tup1 = (1)
print(tup1)
print(type(tup1))
tup2 = (1,)
print(tup2)
print(type(tup2))

(3)字典

①基本操作

#键（key）是索引，必须是字符串、数字、元组，且唯一；值（value）是数据，不一定唯一。字典无序
info_dict = {"name":"张三",
             "age":18,
             "gender":"boy"}
#01取值
print(info_dict["name"])

#02增加 and 修改
info_dict["height"] = 1.75
"""当键（key）在字典中不存在时，会增加键值对"""
info_dict["name"] = "李四"
"""当键（key）在字典中存在时，会修改原来的值"""

#03删除
info_dict.pop("gender")

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

#05合并字典
"""注意，当被合并的字典中出现原已存在的键值对时，会覆盖原来的值"""
temp_dict = {"age":20,
             "country":"China"}
info_dict.update(temp_dict)

#06清空字典
info_dict.clear()

print(info_dict)

②拓展操作

# 遍历字典
s1 = {'name':'Alex', 'num':1001, 'score':91.5}
for k,v in s1.items():
    print(k, '->', v)

(4)集合

#创建一个集合可以使用 {} 和 函数set([, 1 argument])，集合是一个无序且不重复的组成（即集合具有去重复的作用）
x = {'as', 'ee', 1}
y = set('orange')
print(type(x), type(y))
print(y)

C语言：

(1)输入与输出

//利用指针法实现对数组元素的输入和输出 
#include<stdio.h>
//使用指针引用一维数组 
//int main()
//{
//	int a[5], *p=a, i;
//	printf("请输入五维行向量：\n");
//	for(i=0;i<5;i++)
//		scanf("%d", &a[i]);
//	printf("输出向量：\n");
//	for(i=0;i<5;i++)
//		printf("%d ", *(p++));
//	
//	return 0;
//} 
//使用指针引用二维数组 
int main()
{
	int a[3][4]={11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22}, i, j;
	int *p=a;
	for(i=0;i<3;i++)
	{
		for(j=0;j<4;j++)
			printf("%d  ", *(p+i*4+j));			//(p+i*4+j)表示第i行第j列的元素地址
		printf("\n");
	}
	
	return 0;
} 
// a								--二维数组名，首元素地址，第0行地址
// a[0], *(a+0), &a 				--第0行0列元素a[0][0]的地址
// a+1, &a[1]						--第1行的地址
// a[1], *(a+1)						--第1行0列元素a[1][0]的地址
// a[1]+2, *(a+1)+2， &a[1][2]  	--第1行2列元素a[1][2]的地址
// *(a[1]+2), *(*(a+1)+2)，a[1][2]  --第1行2列元素a[1][2]的值

(2)二维数组转置:

#include<stdio.h>
int main()
{
	void sub(int b[][3]);
	int a[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
	int i, j;
	printf("转置前的数组为：\n");
	for(i=0;i<3;i++)
	{
		for(j=0;j<3;j++)
			printf("%d ", a[i][j]);
		printf("\n");
	}
	sub(a);
	printf("转置后的数组为：\n");
	for(i=0;i<3;i++)
	{
		for(j=0;j<3;j++)
			printf("%d ", a[i][j]);
		printf("\n");
	}
	
	return 0;
} 

void sub(int b[][3])
{
	int i, j, t;
	for(i=0;i<3;i++)
		for(j=0;j<i;j++)
		{
			t=b[i][j];
			b[i][j]=b[j][i];
			b[j][i]=t;
		}
}

(3)二维数组找最小数

//现有int整型数组 a[3][4]={{12, 21, 34, 32}, {28, 10, 17, 43}, {19, 54, 38, 27}}，找出数组中数值最小的元素 
#include<stdio.h>
int main()
{
	int i, j, c, b;
	int a[3][4]={{12, 21, 34, 32}, {28, 10, 17, 43}, {19, 54, 38, 27}};
	int min=a[0][0];
	
	for(i=0;i<3;i++)
	{
		for(j=0;j<4;j++)
		{
			if (a[i][j]<min)
			{
				min=a[i][j];
				c=i;
				b=j;
			}
		}
	}
	printf("数组中最小的元素是%d行%d列的%d\n", c+1, b+1, a[c][b]);
	
	return 0;
}

(4)二维数组找鞍点：

/*找出二维数组的鞍点，及其值为所在行中最大、所在列中最小的元素
注：一个二维数组中也可能没有鞍点*/
#include<stdio.h>
int main()
{
	int a[3][4];
	int i, j, k, maxj, max;
	int sum;
	printf("请输入一个3x4矩阵（数字间用空格隔开）:");
	for(i=0;i<3;i++)
		for(j=0;j<4;j++)
			scanf("%d", &a[i][j]);
	for(i=0;i<3;i++)
	{
		max = a[i][0];
		maxj = 0;
		for(j=0;j<4;j++)
			if(a[i][j]>max)
			{
				max = a[i][j];
				maxj = j;
			}
		for(k=0;k<3;k++)
			if(max>a[k][maxj])
				break;
		if(k>=3)
		{
			printf("该二维数组的鞍点为：a[%d][%d]=%d", i, maxj, max);
			break;
		}
	}
	if(i>=3)
	printf("该二维数组没有鞍点。");

	return 0;
}

(5)二维数组相乘

//求二维矩阵相乘的值
#include<stdio.h>
int main()
{
	int a[2][3], b[3][2], c[2][2];
	int i, j, k;
	printf("请输入一个2x3矩阵a：\n");
	for(i=0;i<2;i++)
	{
		for(j=0;j<3;j++)
			scanf("%d", &a[i][j]);	
	} 
	printf("请输入一个3x2矩阵b：\n");
	for(i=0;i<3;i++)
	{
		for(j=0;j<2;j++)
			scanf("%d", &b[i][j]);
	}
	for(i=0;i<2;i++)
	{
		for(j=0;j<2;j++)
		{
			c[i][j]=0;
			for(k=0;k<3;k++)
				c[i][j]+=a[i][k]*b[k][j];
		}
	}
	printf("矩阵a和矩阵b相乘的结果是：\n");			//矩阵c的值 
	for(i=0;i<2;i++)
	{
		for(j=0;j<2;j++)
			printf("%d ", c[i][j]);
		printf("\n");
	}
		
	return 0;
}

16.额外补充

Python

(1)指定缺省参数的默认值

def print_info(name, title, gender=True):
    """
    :param title: 职位
    :param name: 班上同学的姓名
    :param gender: True 是男生，False 是女生
    """

    gender_text = "男生"
    if not gender:
        gender_text = "女生"

    print("[%s]%s 是 %s" % (title, name, gender_text))

print_info("小明","班长",)
print_info("猪妹","科代表",False)

(2)多值参数求和

def sum_num(*args):

    num = 0
    print(args)

    for n in args:
        num += n
    return num

result = sum_num(1,2,3,4,5)
print(result)

(3)多值参数_字典与元组的拆包

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

gl_tuple = (1,2,3,4)
gl_dict = {"name":"小明"}
#使用拆包语法时
demo(*gl_tuple, **gl_dict)
#不使用拆包语法时
demo(1,2,3,4, name = "小明")

(4)使用不定长参数

# 使用不定长参数，其中，*表示元组，** 表示定义参数为字典
def printme(*arg, **args):
    print(arg)
    print(args)
printme(1,2, a=2, b=3)

(5)时间函数

f = lambda x, y : x + y
f(1, 3)
def vfunc(a, *b):
    print(type(b))
    for i in b:
        a += i
    return a
vfunc(1, 2, 3, 4, 5)
from datetime import *
today = datetime.utcnow()
today

(6)文本进度条更新

import time
scale = 10
print("----执行开始----")
for i in range(scale + 1):
    a, b = "**" * i, "··" * (scale - i)
    c = (i / scale) * 100
    print("%{:^3.0f}[{}->{}]".format(c, a, b))
    time.sleep(0.3)
print("----执行结束----")

#单行更新文本进度条
import time
scale = 50
print("执行开始".center(scale // 2, '-'))
t = time.perf_counter()
for i in range(scale + 1):
    a = '*' * i
    b = '·' * (scale - i)
    c = (i / scale) * 100
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, t), end=' ')
    time.sleep(0.05)
print("\n" + "执行结束".center(scale // 2, '-'))

(7)try检测

try:
    alp = "huadudadhjhagdhbx"
    index = eval（input("请输入一个整数："))
    print(alp[index])
except NameError:
    print("输入错误，请重新输入")
except IndexError:
    print("索引值超出范围，请重新输入")
else:
    print("没有发生异常")
finally:
    print("程序执行完毕")

(8)CSV文件的读写

fo = open("/Users/mac/Desktop/picture2016.csv", "r")
ls = []
for line in fo:
    line = line.replace("\n", "")
    ls.append(line.split(","))
print(ls)
fo.close()

(9)田字格的输出

#田字格的输出
n = eval（input("请输入一个奇数："))
a = "— "
b = "┼"
c = "|"
d = " "
m = n // 2
for i in range(n):
    if i in [0,m,n-1]:
        print("{0}{1}{0}{1}{0}".format(b, a*(m-1)))
    else:
        print("{0}{1}{0}{1}{0}".format(c, d*2*(m-1)))

C语言

自定义数据类型

（1）变量类型(按作用域划分)

#include<stdio.h>
int z;					//全局变量，静态存储区 
int main()
{
	int sub();
	int i;				//局部变量 
	for(i=0;i<3;i++)
		sub();
	
	return 0;
}

int sub()
{
	int x=0;			//自动变量，动态存储区，可用关键字auto声明 
	static int y;		//静态局部变量，静态存储区，在程序执行过程中占据固定的存储单元，直到程序执行完毕才被释放 
	++x;
	++y;
	++z;
	printf("x=%d, y=%d, z=%d\n", x, y, z);
	 
}

（2）结构体

详见数据结构学习代码

#include<stdio.h>
int main()
{
	float sum;
	struct Student
	{
		char num[5];
		char name[20];
		char sex;
		int age;
		float score;
	};
	struct Student stu1 = {"1001", "lin", 'M', 19, 94.5}, stu2;
	stu2 = stu1;
	stu2.age = 20;
	stu2.score = 88;
	printf("请输入第二个学生的学号：\n"); 
	scanf("%s", stu2.num);
	printf("请输入第二个学生的姓名：\n");
	scanf("%s", stu2.name);
	sum = stu1.score + stu2.score;
	printf("\nnum	name	sex		age		score \n");
	printf("%s	%s	%c		%d		%.1f\n", 
			stu1.num, stu1.name, stu1.sex, stu1.age, stu1.score);
	printf("\nnum	name	sex		age		score \n");
	printf("%s	%s	%c		%d		%.1f\n", 
			stu2.num, stu2.name, stu2.sex, stu2.age, stu2.score);	 
	printf("\n总分为：%.1f\n", sum);
	
	return 0;
}

（3）共用体

//定义并初始化结构体数组 boy[5]，用于表示5个学生实体。输出5名学生的各项属性，计算总成绩、平均分和不及格人数,并显示不及格学生人数
#include<stdio.h>
int main()
{
	struct Stu
	{
		int num;
		char name[20];
		char sex;
		float score;
	}boy[]={
			{1, "李海", 'M', 94.5},
			{2, "李好", 'M', 89.7},
			{3, "李勉", 'M', 87.0},
			{4, "李茶", 'M', 56.3},
			{5, "李莎", 'M', 55.1},
	};
	
	int i, c=0;
	float ave, sum=0;
	printf("num	name		sex	score\n");
	for(i=0;i<5;i++)
		printf("%-9d%-16s%-7c%.1f\n",
				boy[i].num, boy[i].name, boy[i].sex, boy[i].score);
	for(i=0;i<5;i++)
	{
		sum+=boy[i].score;
		if(boy[i].score<60)
		{
			c+=1;
			printf("不及格学生：%s\n", boy[i].name);
		}
	}
	ave = sum/5;
	printf("总成绩为：%.1f\n", sum);
	printf("平均分为：%.2f\n", ave);
	printf("不及格学生人数为：%d\n", c);
	
	return 0;	
}

（4）枚举变量

//定义枚举变量表示信号灯，并根据变量的不同取值，显示相应信息
#include<stdio.h>
int main()
{
	enum lights 
	{
		red, 
		yellow,
		green
	}lamp;
	for(lamp=red;lamp<=green;lamp++)
		switch(lamp)
		{
			case 0:		printf("红灯禁停\n");break;
			case 1:		printf("黄灯慢行\n");break;
			case 2:		printf("绿灯通行\n");break;
			default:break;
		}
		return 0;
}

Python面向对象

（1）类的声明

①常规方法

class Dog():#类的声明
    def move(self):
        print("提示：你的小可爱正在前往......")
    def attack(self):
        print("提示：你的小可爱会咬人......")
    def info(self):                                                 #实例方法，定义该类的特征信息函数
        print(self)                                                 #打印对象的储存地址
        print("%s 的生命力是：%d" % (self.name, self.hp, self))
        print("%s 的攻击力是：%d" % (self.name, self.atk))

jinmao = Dog()                                     #声明符合该类特征的某一对象，记住此语句一定要放在所有具体定义的属性语句前，否则会报错
hashiqi = Dog()
#赋予具体属性
jinmao.name = "小二"
jinmao.hp = 450
jinmao.atk = 250

hashiqi.name = "五筒"
hashiqi.hp = 550
hashiqi.atk = 350
      
jinmao.move()
jinmao.attack()
jinmao.info()
hashiqi.info()

# print("%s 的生命力是：%d" % (jinmao.name, jinmao.hp))
# print("%s 的攻击力是：%d" % (jinmao.name, jinmao.atk))

②魔法方法

class Dog():
    def move():
        print("提示：你的小可爱活泼好动......")
    def attack():
        print("提示：你的小可爱会咬人......")
    def __init__(self, name, hp, atck, armor):       #魔法函数，可将用户逐步定义的步骤自动归类到一个函数内，则用户只需传入实参即可定义对象属性
        self.name = name
        self.hp = hp
        self.atck = atck
        self.armor = armor
    def info(self):
        print("%s 的生命力：%d" % (self.name, self.hp))
        print("%s 的攻击力：%d" % (self.name, self.atck))
        print("%s 的护甲值：%d" % (self.name, self.armor))
    def __str__(self):
        return self.name                            #在打印对象时，即print(self)，返回的是某个字符串而不是对象存储地址
        
jinmao = Dog("小暖", 2000, 450, 400)
hashiqi = Dog("小二货", 3000, 350, 300)

Dog.move()
Dog.attack()

jinmao.info()
hashiqi.info()

print(jinmao)
print(hashiqi)

print(id(jinmao.name))                    
print(id(hashiqi.name))

（2）类的继承

# 父类
class Dog():
    def __init__(self):
        self.name = "Dog dad"
    def skill(self):
        print("bite people")

class Dog2():
    def __init__(self):
        self.name = "Dog mom"
    def skill(self):
        print("bite dog")
    def skill2(self):
        print("wag tail")
        
# 子类
class Son(Dog2, Dog):                 # 在多类继承时，若有重复和不同的属性，则优先继承第一个类别
    def __init__(self):               # 在内部修改具体属性
        self.name = "Dog son"
    def skill(self):
        print("lick people")
#     def dad_skill(self):            # 第一种方法：在子类中通过调用父类的函数名来实现对父类属性的调用
#         Dog.__init__(self)
#         Dog.skill(self)
    def dad_skill(self):
        super().skill()
    def mom_skill(self):
        super().skill2()

jinmao = Son()

print(jinmao.name)
jinmao.skill()
jinmao.dad_skill()
jinmao.mom_skill()
# jinmao.skill2

（3）类的多态

class Dog():
    def __init__(self):
        self.name = "Dog dad"
    def skill(self):
        print("Bite people")

class son1():
    def skill(self):
        print("Bite man")

class son2():
    def skill(self):
        print("Bite woman")

class son3():
    def skill(self):
        print("Bite child")

son1 = son1()
son2 = son2()
son3 = son3()

son1.skill()
son2.skill()
son3.skill()

(4)迭代器和生成器

# 创建迭代器用 iter()，取其索引可用 next()，迭代器可记住其每一次遍历的位置
names = ["Alex", "Bob", "Clara", "Davie", "Eve"]
it = iter(names)
print(next(it))
print(next(it))
print(next(it))
# 生成器及 函数yield和函数return间的区别
#yield是暂停函数，return是结束函数； 即yield返回值后继续执行函数体内代码，return返回值后不再执行函数体内代码；
#yield返回的是一个迭代器（yield本身是生成器-生成器是用来生成迭代器的）；return返回的是正常可迭代对象（list,set,dict等具有实际内存地址的存储对象）
def gen_num(data):
    if data > 10:
        for i in range(data):
            yield i
    else:
         return data
g1 = gen_num(5)
for num in g1:
    print(num)
print("传入参数5，返回类型：", type(gen_num(5)))
g2 = gen_num(12)
for num in g2:
    print(num)
print("传入参数12，返回类型：", type(gen_num(12)))

C语言结构化过渡到面向对象

详见C语言版数据结构源码