0%

发表于 分类于

C语言之神奇代码

声明：这是网上看到的，还没去弄清楚是什么原理，就先放在这里吧！

1
2
3
main(_){_^448&&main(-~_);putchar(--_%64?32|-~7[__TIME__-_/8%8][">'txiZ^(~z?"-48]>>";;;====~$::199"[_*2&8|_/64]/(_&2?1:8)%8&1:10);}
/*直接复制上面代码到某一编辑器，然后运行就会出现当前的时间。很神奇吧！
下面是效果图：*/

神奇代码

发表于 更新于 分类于

#exit()使用

exit(1)表示异常退出.这个1是返回给操作系统的；

exit(0)表示正常退出。

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
int main()
{
  printf("请输入一个奇数：");
  int num;
  scanf("%d",&num);
  if (num%2==0){
    printf("必须是奇数！\n");
    exit(1);//注：在main函数中exit(0)的效果等同于return 0;
  }
  printf("%d\n",num);
}
/*在该程序中，如果输入的是奇数，就会执行下面的输出语句，将奇数打印出来，否则就会退出。*/

发表于 更新于 分类于

计算机二级考试临时抱佛脚

基础知识

软件危机

软件危机的表现包括：①对软件开发的进度和费用估计不准确；②用户对已完成的软件系统不满意的现象时常发生；③软件产品的质量‘往往靠不住；④软件常常是不可维护的；⑤软件通常没有适当的文档；⑥软件成本在计算机系统总成本中所占的比例逐年上升；⑦软件开发生产率提高的速度远远跟不上计算机应用迅速普及深入的趋势。

地址即指针。

不能将一个整数直接赋给指针变量作为地址；函数的返回值可以说指针。

sizeof函数和int，double字节问题

C语言中用sizeof判断数据类型长度，在vc平台上，整型int占有4字节，double占有8个字节

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "stdio.h"
int main(){
    char a,b,c,d;
    scanf("%c%c",&a,&b);
    c=getchar();d=getchar();
    printf("%c%c%c%c\n",a,b,c,d);
}
/*按照下列方式输入数据：
12<CR>
34<CR>
其中<CR>表示回车。
输出结果为：
12
3

case常量表达式只是起语句标号的作用，并不是该处进行条件判断。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "stdio.h"
int main(){
    int x=1,y=0,a=0,b=0;
    switch (x) {
        case 1:
            switch (y) {
                case 0:a++;break;
                case 1:b++;break;
            }
        case 2:a++;b++;break;
        case 3:a++;b++;
    }
    printf("a=%d,b=%d\n",a,b);
}
/*输出结果为：
a=2,b=1
*/

一个程序选择题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "stdio.h"
int main(){
    int i=0,k=1;
    for (i=0; i<4; i++,i++) {
        for (k=1; k<3; k++) {
        };
    }
    printf("*\n");
}
/*输出结果为：
*
*/

/*解析：由于内层循环后面直接跟了空语句；所以在循环内部什么操作也不做，跳出循环后执行打印语句，所以就打印了一个“*”。
 */

程序选择题复现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "stdio.h"
#include "stdlib.h"//rand函数的头文件为：stdlib.h
#include "time.h"//strand()函数需要的参数为seed，通常利用time(0)的返回值作为seed。time.h是time的头文件
int main(){
    char s[]="012xy\08s34f4w2";//char型字符串总是自动以\0结尾.但是\0介于两个数字之间时，这种自动结尾实效。具体可以自己看看是如何失效的。
    int i,n=0;
    for (i=0;s[i]!=0;i++){
        if (s[i]>='0'&&s[i]<='9') {
            n++;
        }
    }
    printf("%d\n",n);
}
/*所以输出结果为：
 3
 */

第二次函数调用时，第一次的调用已经有些参数的值改变了！

在C语言中，只有在使用时才占用内存单元的变量，其存储类型是：auto和register。

不能在定义结构体的同时，由用结构体类型定义变量。所以，下面结构体的定义语句是错误的。

1
struct ord {int x;int y;int z;}struct ord a;

与处理命令是以#开头的命令，它们不是C语言的可执行命令，这些命令应该在函数之外书写，一般在源文件的最前面书写，但不是必须在起始位置书写；C语言的预处理能够实现宏定义和条件编译等功能。

发表于 分类于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def maoPAO(sz):
    n = len(sz)    #用函数len获取数组的长度存储在变量n中
    for i in range (n):             #用两个循环来执行冒泡排序的步骤
        for j in range(n-i-1):
            if sz[j]>sz[j+1]:
                sz[j],sz[j+1]=sz[j+1],sz[j]
    for k in range(n):            #用一个循环，按大小顺序循环输出数组中的数字
        print(sz[k])


first=[1,4,3,54,43]
maoPAO(first)
'''输出结果为你：
1
3
4
43
54'''

发表于 分类于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#Pyton实现简单的计算器，满足加减乘除
#定义函数
def add(x,y):
	return x+y
def subtract(x,y):
  return x-y
def multiply(x,y):
  return x*y
def devide(x,y):
  return x/y
print("1->加法")                      #规定选择
print("2->减法")
print("3->乘法")
print("4->除法")
yours=int(input("请选择运算类型："))#获取用户选择
a=int(input("first number"))     #获取要运算的数字
b=int(input("second number"))
if yours==1:                    #判断用户需要的运算类型并输出结果
     print("{}+{}={}".format(a,b,add(a,b)))
elif yours==2:
    print('{}-{}={}'.format(a,b,subtract(a,b)))
elif yours==3:
    print('{}-{}={}'.format(a, b, multiply(a, b)))
else:
    print('{}-{}={}'.format(a, b,devide(a, b)))

'''运行结果为：
1->加法
2->减法
3->乘法
4->除法
请选择运算类型：4
first number1000
second number10
1000-10=100.0
'''

发表于 更新于 分类于

字符串练习题

基础练习

1.编写程序，对任意输入的字符串，统计其中的大写字母和小写字母的个数。例如， 输入字符 串: AAaaBBb123CCccccd ，则应输出结果:upper = 6， lower = 8。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include "stdio.h"
#include <string.h>
void jc1(char zifu[],int i,int upper,int lower);
void jc1(char zifu[],int i,int upper,int lower)
{
    while (i<=strlen(zifu)) {
        if (zifu[i]>=65&&zifu[i]<=90) {
            upper++;
        }
        else if (zifu[i]>=97&&zifu[i]<=122){
            lower++;
        }
        i++;
    }
    printf("upper:%d,lower:%d\n",upper,lower);
}

int main()
{
    char zifu1[]={"Hello the world"};
    jc1(zifu1,0,0,0);
    char zifu2[]={"Python is the best LANGUAGE!"};
    jc1(zifu2,0,0,0);
}
/*输出结果为
upper:1,lower:12
upper:9,lower:14
Program ended with exit code: 0	*/

2. 用字符数组存储任意输入的一串字符，求其最大字符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//基础2
#include "stdio.h"
#include <string.h>
void jc2(char zifu[],int i,char max);//声明函数
void jc2(char zifu[],int i,char max)//定义函数，其中定义了字符数组zifu,整型变量i，字符型变量max
{   max=zifu[0];                    //初始化字符型变量max等于字符数组中第一个字符,并认为其为最大字符
    while (i<=strlen(zifu)-1) {           //限制循环次数，防止下标越界
        if (max<zifu[i]) {          //判断max这个字符是否小于后一个字符
            max=zifu[i];            //如果比后一个字符小，就让后一个字符称为max
        }
        i++;
    }
    printf("最大的字符是：%c\n",max);//输出max字符的值
}

int main()                          //调用函数
{
    char zifu1[]={"Hello the world"};
    jc2(zifu1,1,'\0');
    char zifu2[]={"Python is the best LANGUAGE!"};
    jc2(zifu2,1,'\0');
}
/*输出结果为：
 最大的字符是：w
 最大的字符是：y
 Program ended with exit code: 0*/

3. 编写一个程序，将字符数组s2中的全部字符复制到字符数组s1中，不用 strcpy 函数。注意，复 制时，’ \0’ 也要复制过去。‘ \0’ 后面的字符不复制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//基础3
#include "stdio.h"
#include "string.h"
void copy(char zifu1[],int i,int j);//声明函数
void copy(char zifu1[],int i,int j){//定义函数，其中包括三个参数：字符数组zifu1,整型变量i，整型变量j.
    char zifu2[strlen(zifu1)+1];//定义一个长度和zifu1相同的空字符数组
    while (i<=strlen(zifu1)) {//执行循环，控制次数
        zifu2[i]=zifu1[i];//将zufu1原样复制到zifu2
        i++;
    }
    while (j<=strlen(zifu2)-1) {//这里-1是为了输出不包括末尾的f'\0'
        printf("%c",zifu2[j]);//执行输出1
        j++;
    }
    printf("\n");            //换行
    j=0;                     //重新初始化j
    while (j<=strlen(zifu2)) {//这里没有-1，是为了和输出1做比较
        printf("%c",zifu2[j]);//执行输出2
        j++;
    }
    printf("\n");           //换行
}                           //输出结果1和2相同，说明zifu1末尾的'\0'也复制到了zifu2当中
int main()                  //执行函数，完成任务
{
    char zifu1[]={"Hello the world"};
    copy(zifu1,0,0);
}
//输出结果为：
//Hello the world
//Hello the world
//Program ended with exit code: 0

4. 对字符串 a 中的字符由小到大排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//基础4
#include "stdio.h"
#include "string.h"
void  px(char zifu[],int i,int j,char exchange);        //声明函数
void  px(char zifu[],int i,int j,char exchange){        //定义函数，其中包括四个参数
    printf("原来的字符串是：\n%s\n",zifu);
    for (i=0;i<=strlen(zifu)-1;i++) {                   //执行两个循环，使用冒泡排序法对字符串中的字符按照从小到大的顺序排列
        for (j=0; j<=strlen(zifu)-1-i; j++) {
            if (zifu[j]>zifu[j+1]) {
                exchange=zifu[j+1];
                zifu[j+1]=zifu[j];
                zifu[j]=exchange;
            }
            exchange='\0';
        }
    }
    i=0;                                            //让i重新等于0，避免呢过多的变量定义
    printf("重新排序后的字符数组是：\n");
    while (i<=strlen(zifu)+1) {                     //执行循环，输出字符串
        printf("%c",zifu[i]);
        i++;
    }
    printf("\n");                                   //为了多个测试结果的美观，多输出两个换行
    printf("\n");
}
int main()                                          //调用函数，实现多组测试
{
    char zifu1[]="bcadefzrea?!#%^";
    px(zifu1,0,0,'\0');
    char zifu2[]="987654321123456789";
       px(zifu2,0,0,'\0');
}

/*原来的字符串是：
bcadefzrea?!#%^
重新排序后的字符数组是：
!#%?^aabcdeefrz

原来的字符串是：
987654321123456789
重新排序后的字符数组是：
112233445566778899

Program ended with exit code: 0*/

6.下面程序输入一字符串，并将其中的大写字母改变成小写字母，完成程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main()                                 
{
    int i=0;
    char s[120];
    printf("Enter a string.\n");
    scanf("%s",s);              
    while (i<=119) {
        if (s[i]>='A'&&s[i]<='Z') {
            s[i]=s[i]-'A'+'a';
        }
        i++;
    }
    printf("%s\n",s);
}

答案为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main()                                  //因为是填空题，所以只进行了一组测试
{
    int i=0;
    char s[120];
    printf("Enter a string.\n");
    scanf("%[^\n]%*c",s);              //scanf函数获取含空格字符串不能使用%s,因此这里改为了%[^\n]%*c
    while (i<=119) {
        if (s[i]>='A'&&s[i]<='Z') {
            s[i]=s[i]-'A'+'a';
        }
        i++;
    }
    printf("%s\n",s);
}
/*输出结果为：
 Enter a string.
 I LOVE pyhton!
 i  love pyhton!
 */

进阶

1.设计并测试一个函数，其功能是输出输入行(长度 <=1024 )里所有的单词，并丢掉该行中其 他的字符。一个单词的定义是一串字符，其中不含空格、制表符和换行符等其它字符。例如， 输入行: 1234word?_12number +234 输出: word number

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//进阶1
#include <stdio.h>
#include "string.h"
void jj1(char zifu[],int i);                        //声明函数
void jj1(char zifu[],int i){                        //定义一个无返回类型且包含两个形参的函数
    while (i<=strlen(zifu)-1) {                     //执行循环，控制次数，其中用strlen函数获取字符串的长度
        if ((zifu[i]>='A'&&zifu[i]<+'Z')||(zifu[i]>='a'&&zifu[i]<+'z')) {//使用if判断字符数组中的每一个字符是否在字母表中
            printf("%c",zifu[i]);                                        //如果是，则依次输出每个字符
        }
       else{                                                             //否则，输出一个空格，确保不同单词之间的间隔
                  printf(" ");
              }
        i++;
    }
    printf("\n");                                                       //函数末尾输出一个空格，确保完成一次函数后换行再执行下一次
}
int main(){                                                             //在主函数中，执行自定义函数jj1
    char zifu1[]={"happy2019cqut*&^%$world}+)@™"};
    jj1(zifu1,0);
    char zifu2[]={"1234word?_12number _+_234"};
    jj1(zifu2,0);
}
/*输出结果为：
 happy    cqut     world
    word    number
Program ended with exit code: 0
 */

6.输入一个字符串，统计各字母出现的次数，并按字母出现的多少输出(先输出字母出现多的， 次数相同的按字母表顺序输出，不出现的字母不输出)。 例:输入: 5b3a+4-hdeh5dh? 输出: h 3 d 2 a 1 b 1 e 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
//进阶6                                     //本题没有进行多组测试，因为要计算每一个字母的个数m，这本身就是一种测试
#include "stdio.h"
#include "string.h"
int main(){
    int letter[26];int i=0;int j=0;int h=0;;unsigned long m=0;
    while (h<=25) {                         //执行循环，初始化整型数组letter，使其每一个数s都为0
        letter[h]=0;
        h++;
    }
    char zifu[]="hhhddabefgasifgagfaffgagcnmaohgvzf";//初始化字符串
    m=strlen(zifu);
    while (i<=strlen(zifu)-1) {            //执行循环，统计26个字母出现的次数
        if (zifu[i]=='A'||zifu[i]=='a') {
            letter[0]++;
        }
        if (zifu[i]=='B'||zifu[i]=='b') {
            letter[1]++;
        }
        if (zifu[i]=='C'||zifu[i]=='c') {
            letter[2]++;
        }
        if (zifu[i]=='D'||zifu[i]=='d') {
            letter[3]++;
        }
        if (zifu[i]=='E'||zifu[i]=='e') {
            letter[4]++;
        }
        if (zifu[i]=='F'||zifu[i]=='f') {
            letter[5]++;
        }
        if (zifu[i]=='G'||zifu[i]=='g') {
            letter[6]++;
        }
        if (zifu[i]=='H'||zifu[i]=='h') {
            letter[7]++;
        }
        if (zifu[i]=='I'||zifu[i]=='i') {
            letter[8]++;
        }
        if (zifu[i]=='J'||zifu[i]=='j') {
            letter[9]++;
        }
        if (zifu[i]=='K'||zifu[i]=='k') {
            letter[10]++;
        }
        if (zifu[i]=='L'||zifu[i]=='l') {
            letter[11]++;
        }
        if (zifu[i]=='M'||zifu[i]=='m') {
            letter[12]++;
        }
        if (zifu[i]=='N'||zifu[i]=='n') {
            letter[13]++;
        }
        if (zifu[i]=='O'||zifu[i]=='o') {
            letter[14]++;
        }
        if (zifu[i]=='P'||zifu[i]=='p') {
            letter[15]++;
        }
        if (zifu[i]=='Q'||zifu[i]=='q') {
            letter[16]++;
        }
        if (zifu[i]=='R'||zifu[i]=='r') {
            letter[17]++;
        }
        if (zifu[i]=='S'||zifu[i]=='s') {
            letter[18]++;
        }
        if (zifu[i]=='T'||zifu[i]=='t') {
            letter[19]++;
        }
        if (zifu[i]=='U'||zifu[i]=='u') {
            letter[20]++;
        }
        if (zifu[i]=='V'||zifu[i]=='v') {
            letter[21]++;
        }
        if (zifu[i]=='W'||zifu[i]=='w') {
            letter[22]++;
        }
        if (zifu[i]=='X'||zifu[i]=='x') {
            letter[23]++;
        }
        if (zifu[i]=='Y'||zifu[i]=='y') {
            letter[24]++;
        }
        if (zifu[i]=='Z'||zifu[i]=='z') {
            letter[25]++;
        }
        
        i++;
    }
    while (m>=1) {j=0;          //执行循环控制次数，以确保只输出字母个数超过1的
        while (j<=25) {         //执行熏黄，从高到低比较字母个数
            if (letter[j]==m) {
                printf("%c:%d\n",j+97,letter[j]);//输出字母个数和
            }
            j++;
        }
        m=m-1;
    }
}
/*运行结果为：:6
f:6
g:6
h:4
d:2
b:1
c:1
e:1
i:1
m:1
n:1
o:1
s:1
v:1
z:1
Program ended with exit code: 0*/

7. 有一篇文章，共有 3 行文字，每行有80个字符。要求分别统计出其中英文大写字母、小写字母、 数字、空格以及其它字符的个数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>                  //Name:雷博闻 Student ID：11923040207
#include "string.h"                 //进阶7
int main(){
    char zifu[3][80]={                                                                      //c定义一个多维字符数组并初始化
        "Its name might sound a little plain, but the grey-headed albatross is the most e",
        "Not only a majestic bird, the grey-headed albatross is a literal a world recoreq",
        "In 2003, The Guinness Book of Records gave them the title of world’s fastest h"
                        };
            int i=0,j=0,upper=0,lower=0,numbers=0,others=0;
    while (i<=2) {j=0;                                                                      //外循环，控制行数。j=0是为了重新初始化k列数
        while (j<=79) {                                                                     //内循环，控制列数
            if((zifu[i][j]>='A')&&(zifu[i][j]<='Z')){                                       //判断该字符是否是大写字母，是则upper+1，不是则进行下一判断
                upper++;
            }
            else if ((zifu[i][j]>='a')&&(zifu[i][j]<='z')){                                 //判断该字符是否是小写字母，是则lower+1，不是则进行下一判断
                lower++;
            }
            else if ((zifu[i][j]>='0')&&(zifu[i][j]<='9')){                                 //判断该字符是否是数字，是则numbers+1，不是则进行下一判断
                numbers++;
            }
            else{
                others++;
                //都不满足，则others+1
            }
            j++;
        }
        i++;
    }
    printf("大写字母的个数是：%d\n小写字母的个数是：%d\n数字的个数是在：%d\n其他字符的个数是：%d\n",upper,lower,numbers,others);
    //分别输出upper，lower，numbers和others的值
    printf("%d\n",upper+lower+numbers+others);//输出upper，lower，numbers和others值的综合，总和为240，则程序正确
}
/*输出结果：
 大写字母的个数是：7
 小写字母的个数是：180
 数字的个数是在：4
 其他字符的个数是：49
 240
 Program ended with exit code: 0*/

发表于 分类于

gets(),puts()函数

使用gets(),puts()函数实现字符串的输入和输出

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
`\#include "stdio.h"`

`\#include <string.h>`

`**int** main()`

`{  **char** you[]={"12345"};`

  `**char** password[100]={};`

  `gets(password);`

​    `**if** (strcmp(password,you)==0) {`

​      `printf("Welcome!");`

  `}`

​    `**else**{`

​      `printf("You are not right");`

​    `}`

`}

发表于 分类于

操作字符串的函数

strcpy()

1
2
3
4
5
6
7
#include<stdio.h>
#include<string.h>
int main(){
char a[100]="hello";
char b[100];
strcpy(b,a);
printf("b:%s\n",b);}

strcat()

1
2
3
4
5
6
7
8
#include<stdio.h>
#include<string.h>
//strcat()将后面的字符串接到前面的字符串后面
int main(){
char a[100]="I love you,";
char b[100]="999!";
strcat(a,b);//注意这里是连接了b字符串到a字符串
printf("a:%s\n",a);}//输出的a字符串即是加工后的字符串

输出结果是: I love you,999

srtlen()

1
2
3
4
5
6
7
8
9
10
11
12
#include<stdio.h>
#include<string.h>
//strlen()用于获取字符串的长度
int main(){
char a[100]="I love you,";
char b[100]="999!";
int len1=0,len2=0;
len1=strlen(a);
len2=strlen(b);
printf("a字符串的长度是：%d,b字符串的长度是:%d\n",len1,len2);}
//输出两个字符串的长度
//输出结果分别是：a字符串的长度是：11,b字符串的长度是:4

发表于 更新于 分类于

list操作

索引及负数索引

1
2
3
4
5
6
7
8
9
10
11
a = ['i','love','you']
#执行索引输出列表
print(a[1])
print(a[0:3])
print(a[-1])
print(a[1:-1])
#输出结果为：
'''love
['i', 'love', 'you']
you
['love']'''

元素的增加

1
2
3
4
5
6
7
8
9
10
11
12
a = ['i','love','you']
a.append("999")#尾部➕1
print(a[:])
a.insert(4,'very much!')#指定位置➕
print(a[:])
a.extend(["do",'you know'])#尾部➕2***注意extend的使用格式***
print(a[:])
#输出结果为：
'''['i', 'love', 'you', '999']
['i', 'love', 'you', '999', 'very much!']
['i', 'love', 'you', '999', 'very much!', 'do', 'you know']
'''

元素的搜索

1
2
3
4
5
6
#使用index对列表中的元素进行搜索，返回的是搜索元素在列表中的序号
a = ['i','love','you']
print(a.index('you'))
#输出结果是：
'''2
'''

元素的删除

1
2
3
4
5
6
7
8
9
10
11
12
a = ['i','love','you']
#remove方法
a.remove('you')#如果列表中有多个"you"，则会删除第一个
print(a)
#pop方法
a = ['i','love','you']
print(a.pop())#执行pop方法的同时输出会输出被删掉的最后一个元素
print(a)#再次输出原有列表发现列表已经改变
#输出结果为：
'''['i', 'love']
you
['i', 'love']'''

列表的运算

1
2
3
4
5
6
7
8
9
10
#注意只支持+和*
a = ['i','love','you']
b =['you','!']
c=[2,2,2]
d = ['you']
print(a+b)
print(c*2)
#输出结果为：
'''['i', 'love', 'you', 'you', '!']
[2, 2, 2, 2, 2, 2]'''

发表于 更新于 分类于

Python时间与日期

time()模块

时间戳

时间间隔是以秒为单位的浮点小数。

每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

输出当前时间戳

1
2
3
4
5
6
import time as ti
now = ti.time()
print(now)
#当前时间2019/11/28 23:55
#输出结果为
#1574956554.693932

获取当前时间

1
2
3
4
5
6
import time as ti#导入time模块
Localtime=ti.localtime(ti.time())#将当前时间戳的浮点数传递给localtime函数
print(Localtime)#输出当前时间
#输出结果：
#time.struct_time(tm_year=2019, tm_mon=11, tm_mday=29, tm_hour=0, tm_min=33, tm_sec=7, tm_wday=4, tm_yday=333, tm_isdst=0)
#当前时间是以时间元组方式输出的，下面会讲到时间元组

时间元组

序号 属性 值
0 tm_year 2008
1 tm_mon 1到12
2 tm_mday 1到31
3 tm_hour 0到23
4 tm_min 0到59
5 tm_sec 0到61
6 tm_wday 0到6(周一是0)
7 tm_yday 1到366
8 tm_isdst -1,0,1,-1是决定是否为夏令时的旗帜

获取格式化时间

1
2
3
4
5
6
#使用了asctime()函数
import time as ti
now=ti.asctime(ti.localtime(ti.time()))
print(now)
#输出结果是：
# Fri Nov 29 00:37:59 2019

Calender()模块

获取某月月历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import calendar as ca
#使用了calenda模块
yue = ca.month(2019,11)#前面是年份，后面是月份
print("以下是2019年11月的月历")
print(yue)
#输出结果是：
'''以下是2019年11月的月历
   November 2019
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30


Process finished with exit code 0'''

time模块具体配置请参考Python官方文档。