数据类型:int,bool,str,list, tuple元组,dict字典。

  1.数字:12,3,4

  在使用print打印数字时,在终端界面中无法判断出打印的是什么类型,当我们需要知道一个值是什么类型的时候,此时可以使用tpye()。

1 #-*- encoding -*-
2
3 print(100, type(100)) #100, <class, int>
4 print('100', type('100')) #100, <class. str>

  2.字符串:str,python凡是由引号引起来的都是字符串,三个引号引起来的内容赋值给一个变量,则是一个大字符串。字符串与字符串可相加(字符串拼接),字符串可与数字相乘。主要用来存储少量数据,进行操作。

1 #-*- encoding:utf-8 -*-
2
3 print('I\'m a teacher') #字符串中包含引号加\
4
5 print("I'm a teacher") #字符串中包含引号,外面是双引号

  2.1 字符串索引与切片

 1 s = 'ABCDLSESRF'
2 # 索引
3 s1 = s[0]
4 print(s1) # A
5 # 取ABCD 切片取:顾头不顾尾
6 s2 = s[0:4]
7 print(s2)
8 # 取F
9 s3 = s[-1]
10 print(s3)
11 # 取A到F
12 s4 = s[0:] # == s4 = s[:]
13 print(s4)
14
15 s = 'ABCDLSESRF'
16 # 只取ACL s[首:尾:步长] 步长默认是1
17 s5 = s[0:5:2] # 最后一个2表示步长,从0开始隔1个取一个字符。如果没有最后一个步长,默认是1
18 print(s5)
19 # 取DCBA
20 s6 = s[3::-1]
21 print(s6)
22 # 取DB
23 s7 = s[3::-2]
24 print(s7)
25 # 倒着取完
26 s8 = s[-1::-1] # == s8 = s[::-1]
27 print(s8)

  2.2 字符串的操作

  按照需求对字符串进行操作

 1 # 字符串的操作
2 s = 'alexWUsir'
3 # 首字母大写,其余大小
4 s1 = s.capitalize()
5 print(s1)
6
7 # 全部变为大写
8 s2 = s.upper()
9 print(s2)
10
11 # 全部变为小写
12 s3 = s.lower()
13 print(s3)
14
15 # 像在输入验证码的时候,常常提示不区分大小写,此时这些字符串操作方法就能满足需求
16
17 # 大写变小写,小写变大写
18 s4 = s.swapcase()
19 print(s4)
20
21 s = 'alex egon*wusir'
22
23 # 让每个特殊字符(或数字)隔开的字符串首字符大写
24 s5 = s.title() # 会将字符串内容中的被特殊字符隔开的每个字符串的首字母变为大写
25 print(s5)
26
27 s = 'alexWUsir'
28
29 # 加入宽度后,空隔填充,进行居中
30 s5 = s.center(20)
31 print(s5)
32
33 # 加入宽度后,在加入填充的字符,进行居中
34 s6 = s.center(20, '#')
35 print(s6)
36
37 s = 'al\tsir'
38 # 当出现\t时,包括前面,不够参数长度的补上参数长度
39 s7 = s.expandtabs(4)
40 print(s7) # al sir
41
42 # 公共方法,长度
43 s = 'alexWUsir'
44 l = len(s)
45 print(l)

  2.2 字符串中的方法

 1 # 判断一个字符串以什么为开头,是返回True
2 s = 'alexWUsir'
3 s8 = s.startswith('al')
4 print(s8) # True
5
6 # 判断字符串的第二位到最后是否以e开头
7 s9 = s.startswith('e', 2)
8 print(s9) # True
9
10 # 判断字符串的第二位到第四位是否以e开头
11 s10 = s.startswith('e', 2, 5)
12 print(s10) # True
13
14 # 查找字符串中有没有L这个元素
15 s = 'alexWUsir'
16 s11 = s.find('W') # 返回这个元素对应的索引
17 print(s11) # 4
18
19 # 查找字符串的第二位到第四位有没有W这个元素
20 s = 'alexWUsir'
21 s12 = s.find('W', 2, 5)
22 print(s12) # 4
23
24 # 查找字符串的第二位到第四位有没有A这个元素
25 s = 'alexWUsir'
26 s13 = s.find('A', 2, 5)
27 print(s13) # 找不到返回-1
28
29 # 通过元素找索引,这种方法找不到会报错
30 # s14 = s.index('A')
31 # print(s14)
32
33 # 去除一个字符串的前后空格
34 s = ' alexWUsir '
35 s15 = s.strip() # 默认删除前后空格
36 print(s15) # alexWUsir
37
38 # 去除一个字符串中的%
39 s = 'alexWUsir%'
40 s16 = s.strip('%')
41 print(s16) # alexWUsir
42
43 # 去除字符串中的*%
44 s = '*alexWUsir%'
45 s17 = s.strip('*%')
46 print(s17) # alexWUsir
47
48 # 去除字符串中的*%
49 s = '*a%lexWUsir%'
50 s18 = s.strip('*%')
51 print(s18) # a%lexWUsir
52
53 # rstrip 从右删
54 # lstrip 从左删
55
56 # 字符出现个数
57 s = 'alexaa wusirl'
58 s19 = s.count('a')
59 print(s19) # 3
60
61 # split 将字符串按照规定的分割。一份为2,作为分割的字符消失。同时也是str转list
62 s = 'alex wusir why'
63 l = s.split() # 默认以空格分割
64 print(l) # ['alex', 'wusir', 'why']
65
66 s = ':alex:wusir:why'
67 l1 = s.split(':') # 以:分割
68 print(l1) # ['', 'alex', 'wusir', 'why']
69
70 # format的格式化输出.三种玩法,高大上的
71 # format第一种
72 s = '我叫{}, 今年{}, 爱好{}'.format('why', 25, 'python')
73 print(s) # 我叫why, 今年25, 爱好python
74
75 # format第二种
76 s = '我叫{0}, 今年{1}, 爱好{2}, 我是{0}'.format('why', 25, 'python')
77 print(s) # 我叫why, 今年25, 爱好python, 我是why
78
79 # format第三种
80 s = '我叫{name}, 今年{age}, 爱好{hobby}, 我是{name}'.format(name = 'why', age = 25, hobby = 'python')
81 print(s) # 我叫why, 今年25, 爱好python, 我是why
82
83 # 替换
84 s = '老李,老王,老将, 老李'
85 s20 = s.replace('老李', '老大')
86 print(s20) # 老大,老王,老将, 老大
87
88 s = '老李,老王,老将, 老李'
89 s21 = s.replace('老李', '老大', 1)
90 print(s21) # 老大,老王,老将, 老李
91
92 name = 'whylinux123'
93 print(name.isalnum()) # 字符串是否由字母或数字组成
94 print(name.isalpha()) # 字符串是否只由字母组成
95 print(name.isdigit()) # 字符串是否只由数字组成
96
97 # 以上操作对原字符串没有影响,都是新生成了一个字符串

  2.3 补充

  2.3.1 判断一个字符串中是否含有非法字符,或不含非法字符

1 s = 'fds苍进空adf'
2
3 if '苍井空' in s:
4 print('您的评论存在敏感词汇')
5 s = 'fsdfsdz'
6 if '苍井空' not in s:
7 print('没有非法字符')

  3.bool:布尔值,Flase,True。

  没有什么方法,说下数据类型转换。如果将int类型的转换为str,则只需str()将int类型的数字或变量包起来即可,没有要求。如果将str类型的转换为int类型,只需将int()将str类型的字符串或变量包含起来即可,但是有要求,字符串只能是数字字符。

  数字转换为bool值

1 i = 10
2 j = 0
3 print(bool(i)) # True
4 print(bool(j)) # False

  bool值转换为数字

1 i = 10
2 j = 0
3 print(bool(i)) # True
4 print(bool(j)) # False

  字符串与bool值

1 s =''
2 print(bool(s)) #False
3 s = '0'
4 print(bool(s)) #True
1 s = ''
2 if s:
3 pass
4 else:
5 print('空的') #

  4.int

  可以在PyCharm中,输入int后,点击Ctrl+鼠标左键,可以跳到class中看有哪些操作方法,这里只记住一个就行,其他有需要了解看class或百度。

  bit_length(),将int类型的数据转换为二进制,然后返回该数字占用二进制最少的bit位数。

1 # bit_length()方法,将int类型的数据
2 # 转换为二进制用的最少位数
3 # 数字3 0000 0011 所以是2
4 # 数字5 0000 0101 所以是3
5 # 数字1 0000 0001 所以是1
6 i = 3
7 print(i.bit_length()) #3

  5.list

  列表,可以存储大量的数据。从数据库取出数据,如果需进行处理,可以从数据库将数据取出到list列表中

  其他语言中也有类似于列表的数据类型,如js中的数组,他是以[]括起来的,每个元素以逗号隔开,而且他里面可以存放各种数据类型的元素,比如:

  li = ['alex', 123, True, (1, 2, 3, 4), [1, 2, 3, '小明'], {'name' :  'alex'}]    对象也同样可以放入

  列表相对于字符串,不仅可以存储不同的数据类型,而且可以存储大量的数据,列表是有序的,有索引值,可切片。有序就证明有索引值,有切片。

1 li = ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'why']
2
3 print(li[0]) # alex
4 print(li[1]) # [1, 2, 3]
5 print(li[0:3]) # ['alex', [1, 2, 3], 'wusir']
6
7 # 列表的其他操作切片等与字符串一样,因为是有序的,所以有索引值,所以可以切片

  5.1 列表的操作方法

 

 1 li = ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'why']
2
3 # 增加 append
4 li.append('xx')
5 print(li) # ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'why', 'xx']
6
7 li.append(1)
8 print(li) # ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'why', 'xx', 1]
9
10 # 增加insert 按照索引位置插入增加
11 li.insert(5, 'yy')
12 print(li) # ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'yy', 'why', 'xx', 1]
13
14 # 迭代的增加,迭代:由多个元素组成的对象是可迭代的。增加的是可迭代对象的每个元素,加入到最后
15 li.extend('qq')
16 print(li) # ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'yy', 'why', 'xx', 1, 'q', 'q']
17
18 li = ['alex', 'wusir', 'egon', '女神', 'why']
19
20 # 删 pop,类似出栈概念,返回出栈者
21 li.pop() # 按索引去删除,默认弹出最后一个
22 print(li)
23
24 # 删 remove, 按元素去删,没有返回值
25 li.remove('alex') # ['wusir', 'egon', '女神']
26 print(li)
27
28 # 清空列表
29 li.clear()
30 print(li) # []
31
32 # 在内存中将列表删除
33 del li
34 # print(li) # 报错,li没有定义
35
36
37 li = ['alex', 'wusir', 'egon', '女神', 'why']
38
39 # 切片去删,删除一片
40 del li[0:3]
41 print(li) # ['女神', 'why']
42
43
44 # 改, 按照索引去改
45 li[1] = '男神'
46 print(li) # ['女神', '男神']
47
48 li = ['alex', 'wusir', 'egon', '女神', 'why']
49 # 改, 切片去改,切片去改,只能使用可迭代的对象作为赋值的对象
50 li[0:2] = 'python' # 前两位去除后,位置变空,填充赋值的对象的迭代元素
51 print(li) # ['p', 'y', 't', 'h', 'o', 'n', 'egon', '女神', 'why']
52
53 li = ['alex', 'wusir', 'egon', '女神', 'why']
54 li[0:2] = [1, 2, 4, 'xxx'] # 前两位去除后,位置变空,填充赋值的对象的迭代元素
55 print(li) # [1, 2, 4, 'xxx', 'egon', '女神', 'why']
56
57 li = ['alex', 'wusir', 'egon', '女神', 'why']
58 # li[0:2] = 12 # 报错 12不可迭代
59 # print(li)
60
61 # 查 查列表中的每一个元素
62 for i in li:
63 print(i)
64
65 # 查 切片查
66 print(li[0:2]) # ['alex', 'wusir']
67
68 # 公共方法, len 计算可迭代对象中的含几个元素
69 print(len(li)) # 5
70
71 # 公共方法,count 计算元素的出现次数
72 print(li.count('alex'))
73
74 # 找列表中的元素的索引值, index 找不到会报错
75 print(li.index('why')) # 4
76
77 li = [1, 5, 4, 7, 6, 2, 3, 9, 0]
78 # 列表元素正向排序 sort, 从小到大排序
79 li.sort()
80 print(li) # [0, 1, 2, 3, 4, 5, 6, 7, 9]
81
82 # 列表元素反向排序 sort(reverse=True)
83 li.sort(reverse=True)
84 print(li) # [9, 7, 6, 5, 4, 3, 2, 1, 0]
85
86 # 列表元素顺序反转
87 li.reverse()
88 print(li) # [0, 1, 2, 3, 4, 5, 6, 7, 9]

  5.2 列表的嵌套

 1 # 列表的嵌套
2
3 li = ['why', 'alex', '武藤兰', 'python', ['wusir', 'egon', 89], 23]
4
5 print(li[2][1]) # 藤
6
7 li[0]= li[0].capitalize() # 第一个元素变为首字符大写
8 print(li) # ['Why', 'alex', '武藤兰', 'python', ['wusir', 'egon', 89], 23]
9
10 li[4][0] = li[4][0].upper() # 将wusir变为大写
11
12 print(li) # ['Why', 'alex', '武藤兰', 'python', ['WUSIR', 'egon', 89], 23]

  6.tuple元组

  也叫只读列表,只能读,不能被修改。可以查询但不能被更改。同时可以切片。

 1 # 元祖 只读列表,可循环查询,可切片
2 # 儿子不能被改,孙子可可能可以改
3 tu = (1, 2, 3, 'alex', [2, 3, 4, 'why'], 'egon') # 里面的整个元素不能被改,但是元素如果不是元组是列表,列表中的内容可以改
4
5 print(tu[3]) # alex
6
7 print(tu[0:4]) # (1, 2, 3, 'alex')
8
9 for i in tu:
10 print(i)
11
12 tu[4][3] = tu[4][3].upper() # why 改为大写
13
14 print(tu) # (1, 2, 3, 'alex', [2, 3, 4, 'WHY'], 'egon')
15
16 # tu[4] = tu[4].append('SB') # 报错,
17 tu[4].append('SB')
18 print(tu) # (1, 2, 3, 'alex', [2, 3, 4, 'WHY', 'SB'], 'egon')

  7.dict字典

  可存储大量数据,关系型。关系型数据要存储在字典中。

  1 # dict
2 '''
3 数据类型划分:可变数据类型,不可变数据类型
4 不可变数据类型:tuple,bool,int str,又叫可哈希
5 可变数据类型:list,dict,set(集合), 又叫不可哈希
6
7 dict key: 必须是不可变数据类型,也就是可哈希,tuple,bool,int,str
8 value:任意数据类型
9
10 dict 优点:二分查找去查询
11 存储大量关系型数据
12 特点:无序的(python3.5包含以前的都是无序的)
13
14 '''
15
16 # dic = {
17 # 'name' : ['why', 'python', '关羽'],
18 # 'py9' : [{'num' : 108, 'avg_age' : 18}],
19 # True : 1,
20 # (1, 2, 3) : 'wuyiyi',
21 # 2 : '赵云'
22 # }
23 #
24 # print(dic)
25
26 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
27
28 # 增
29 dic['high'] = 170 # 没有键就是增加,有就是更改
30 print(dic) # {'high': 170, 'age': 18, 'name': 'why', 'sex': 'male'}
31
32 dic['age'] = 16 # 如果有键值会覆盖
33 print(dic) # {'high': 170, 'age': 16, 'name': 'why', 'sex': 'male'}
34
35 # 增 setdefault
36 dic.setdefault('weight', 120)
37 print(dic) # {'weight': 120, 'high': 170, 'sex': 'male', 'name': 'why', 'age': 16}
38
39 dic.setdefault('age', 20) # 有键值对,不做任何改变,没有那个键值对则添加
40 print(dic) # {'weight': 120, 'high': 170, 'sex': 'male', 'name': 'why', 'age': 16}
41
42
43 # 删 按照键去删
44 print(dic.pop('age')) # 有返回值 16
45 print(dic) # {'sex': 'male', 'name': 'why', 'weight': 120, 'high': 170}
46
47 print(dic.pop('哈哈', None)) # 返回None 没有哈哈这个键时,则返回None,返回值可设置,有哈哈这个键则删除哈哈这个键值对
48 print(dic)
49
50 print(dic.popitem()) # 随机删除 返回值是元组形式的键和值
51 print(dic)
52
53 # 清空字典
54 dic.clear()
55 print(dic)
56 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
57
58 # del也可删除键值对
59 del dic['name']
60 print(dic)
61
62 # 删除字典
63 # del dic
64
65
66 # 改
67 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
68
69 dic['age'] = 25
70 print(dic)
71
72 # 改 update
73 dic2 = {'name' : 'fqq', 'weight' : 120}
74 dic.update(dic2) # 将dic2内容更新到dic中,如果dic中没有则新增,如果dic中有则覆盖
75 print(dic)
76 print(dic2)
77
78
79 # 查
80 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
81 print(dic.keys(), type(dic.keys())) # dic.keys()返回的当成list,返回的list中全是键 dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>
82 print(dic.values()) # 返回的也相当于list,list里面放的全是值 dict_values(['male', 18, 'why'])
83 print(dic.items()) # 返回的也相当于list,list里都是元祖,元组里是键值对 dict_items([('sex', 'male'), ('age', 18), ('name', 'why')])
84
85 for i in dic:
86 print(i) # 打印的全是键
87
88 for i in dic.keys():
89 print(i) # 打印的全是键
90
91 for i in dic.values():
92 print(i) # 打印的全是值
93
94 a = 1
95 b = 2
96 a, b = b, a
97 print(a, b) # 2 1
98
99 a, b = [1, 2]
100 print(a, b) # 1 2
101
102 a, b = [1, 2], [2, 3]
103 print(a, b) # [1, 2] [2, 3]
104
105 a, b = (1, 2)
106 print(a, b) # 1 2
107
108 # ('sex', 'male')
109 # ('name', 'why')
110 # ('age', 18)
111 for i in dic.items(): # items返回的是list,list中有元组,元组内容为键值对
112 print(i)
113
114
115 # sex male
116 # age 18
117 # name why
118 for k, v in dic.items():
119 print(k, v)
120
121
122 # 查
123 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
124
125 print(dic['name']) # why
126
127 # print(dic['sdf']) # 报错,字典中没有这个键值对是会报错
128
129 # 查 get
130 print(dic.get('name')) # why
131 print(dic.get('sdf')) # None 没有不会报错,默认会返回None
132
133 print(dic.get('sdf', '没有这个键')) # 没有这个键, 没有不会报错,会返回设置的值

  7.1 dict的嵌套

 1 # dict嵌套
2
3 dic = {
4 'name' : ['alex', 'wusir', 'python'],
5 'py9' :{
6 'time' : '1213',
7 'learn_money' : 19800,
8 'address' : 'CBD',
9 },
10 'age' : 25
11 }
12
13 # 将age的值改为56
14
15 dic['age'] = 56
16
17 # 将name对应的列表中添加一个新的名字
18 dic['name'].append('赵云')
19
20 # 将wusir变为全大写
21 dic['name'][1] = dic['name'][1].upper()
22
23 # 将py9对应的字典添加一个键值对 female : 8
24 # dic['py9']['female'] = 6 # 或 dic['py9'].setdefault('female', 6)
25
26 print(dic)

  8.for 循环

  for x in 可迭代的对象(由很多个元素的):

    pass

1 s = 'fhdsklfds'
2 for i in s:
3 print(i)
 1 # 循环打印这个list,但是遇到list中的list也要循环打印出
2 li = [1, 2, 3, 5, 'alex', [2, 3, 4, 5, 'why'], 'python']
3
4
5 for i in li:
6 if type(i) == list:
7 for j in i:
8 print(j)
9 else:
10 print(i)

  8.1 补充range

 1 # range 一般都与for配合使用.range 顾头不顾尾。可以看成一个list,但是里面都是数字
2 for i in range(0, 100):
3 pass
4
5 for i in range(10): # 从0开始,可以不写头
6 pass
7
8 for i in range(0, 10, 2): # 可以加步长
9 pass
10
11 for i in range(10, 0, -1): # 可以倒着
12 #print(i)
13 pass
14
15 for i in range(0, 10, -1):
16 print(i) # 什么都没有

  9. 补充join

 1 # join 可迭代对象都可以用其操作
2
3 s = 'alex'
4
5 s1 = '_'.join(s) # a_l_e_x 将s这个可迭代对象,将每个迭代出来的元素用'_'连接,最终返回的是一个str
6
7 print(s1)
8
9 li = ['why', 'alex', '武藤兰', 'python']
10 s = ''.join(li)
11 print(s) # whyalex武藤兰python
12
13 # 想让字符串转换为list可用str的split方法,想让list转换为str可用join方法

  10.补充例子

1 # 获取用户的输入,判断含整体数字的个数
2 info = input('>>>')
3 for i in info: # info因为是不可变的,for认为info不会变,所以遍历的元素这里已经固定,所以下面的赋值并不会这里,
4 if i.isalpha(): # 判断是否是字符
5 info = info.replace(i, ' ') # 将所有字符替换未空格符
6
7 l = info.split() # 默认用any空白字符进行分隔, spilit得到的是list,list中元素全是数字
8
9 print(len(l))

  11.基础类型汇总补充

  想看每个数据类型的所有操作方法,如果使用pycharm,则ctrl + 鼠标左键,可跳过去有所有方法。

 1 # list 在循环list当中,将list中的元素删除
2 lis = [11, 22, 33, 44, 55]
3
4 # 报错,因为list是可变数据类型,不可哈希,删除list中的一个元素后,list中就少一个,而i是0到5,所以后面i索引的位置已经没了t元素
5 # range(len(lis))只认一次,只确定一次,所以range(len(lis))得到5后一直不变
6 # for i in range(len(lis)):
7 # print(i)
8 # print(lis)
9 # del lis[i]
10
11
12
13 # 循环的方式,将lis中的奇数索引位置的数据删除掉
14 # 不可以的方法
15 lis = [11, 22, 33, 44, 55, 66, 99]
16 for i in lis:
17 print(lis.index(i))
18 print(lis)
19 if lis.index(i) % 2 == 1:
20 lis.remove(i)
21
22 print(lis)
23
24
25 # 删除字典中,含有k元素的键值对
26 dic = {'k1' :'v1', 'k2' : 'v2', 'a3' : 'v3'}
27
28 # 此种方法会报错
29 # for i in dic:
30 # if 'k' in i:
31 # print("===")
32 # del dic[i]
33 # 此种方法可以
34 # dic1 = {}
35 # for i in dic:
36 # if 'k' not in i:
37 # dic1.setdefault(i, dic[i])
38 # dic = dic1
39 # print(dic)
40
41 # 此种方法也可以,循环字典删除字典元素不可以,就使用循环字典,将要删除的键放入到list中,循环list进行删除dic
42 l = []
43 for i in dic:
44 if 'k' in i:
45 l.append(i) # l 中全是含有k的键
46 for i in l:
47 del dic[i]
48 print(dic)
49
50 # 不要在循环list和循环dic中删除list和dic元素
51
52 # 元祖
53 tu1 = (1) # 元组中只有一个元素,并且不没有逗号,那此元素是什么类型,就是什么什么类型,并不是元组类型
54 tu2 = (1, ) # 元组括号内有一个元素,并有逗号,就是元组

Python基础数据类型与for循环的更多相关文章

  1. Python基础数据类型-列表(list)和元组(tuple)和集合(set)

    Python基础数据类型-列表(list)和元组(tuple)和集合(set) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 本篇博客使用的是Python3.6版本,以及以后分享的 ...

  2. python基础数据类型考试题

    Python基础数据类型考试题 考试时间:两个半小时                      满分100分(80分以上包含80分及格) 一,基础题. 1,简述变量命名规范(3分) 2,字节和位的关系 ...

  3. 1--Python 入门--Python基础数据类型

    一.Python基础语法 初次使用Python,首先要明确三点: Python的标识符(例如变量名.函数名等),可用字母.数字和下划线构成,不能以数字开头,且区分大小写. Python对于缩进敏感.在 ...

  4. Python基础数据类型-字典(dict)

    Python基础数据类型-字典(dict) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 本篇博客使用的是Python3.6版本,以及以后分享的每一篇都是Python3.x版本的哟 ...

  5. Python基础数据类型题

    Python基础数据类型 题考试时间:三个小时 满分100分(80分以上包含80分及格)1,简述变量命名规范(3分) 1.必须是字母,数字,下划线的任意组合. 2.不能是数字开头 3.不能是pytho ...

  6. Python基础数据类型之集合

    Python基础数据类型之集合 集合(set)是Python基本数据类型之一,它具有天生的去重能力,即集合中的元素不能重复.集合也是无序的,且集合中的元素必须是不可变类型. 一.如何创建一个集合 #1 ...

  7. 老男孩Python==基础数据类型考试题

    转载 # Python基础数据类型考试题 # 考试时间:两个半小时 满分100分(80分以上包含80分及格) # 一,基础题. # 1, 简述变量命名规范(3分) # 1.变量由字母.数字.下划线任意 ...

  8. Python 入门之Python基础数据类型及其方法

    Python 入门之Python基础数据类型 1. 整型:int 用于计算,用于比较 (在赋值的时候先执行等号右边的内容) 1.1 整数的加 a = 10 b = 20 print(a + b) 结果 ...

  9. python基础数据类型--集合(set)

    python基础数据类型--集合(set) 集合是一个数学概念由一个或多个确定的元素所构成的整体叫做集合 集合中的三个特征 1.确定性(元素必须死可hash) 2.互异性(去重) 3.无序性(集合中的 ...

随机推荐

  1. 接入WxPusher微信推送服务出现错误:Content type 'application/x-www-form-urlencoded;charset=UTF-8' not supported

    背景 使用WxPusher微信推送服务 ,可以及时的将服务的一些运行异常信息,发送到自己的微信上,方便了解服务的运行状态(PS:这个服务是免费的). 你可以在这里看到WxPusher微信推送服务的接入 ...

  2. spring boot:用spring security加强spring boot admin的安全(spring boot admin 2.3.0 / spring boot 2.3.3)

    一,spring boot admin的安全环节: 1,修改context-path,默认时首页就是admin, 我们修改这个地址可以更安全 2,配置ip地址白名单,有ip限制才安全, 我们使用了sp ...

  3. 解决selenium.common.exceptions.InvalidArgumentException: Message: invalid argument: invalid 'expiry'

    解决selenium.common.exceptions.InvalidArgumentException: Message: invalid argument: invalid 'expiry'   ...

  4. 第十五章 nginx七层负载均衡

    一.Nginx负载均衡 1.为什么做负载均衡 当我们的Web服务器直接面向用户,往往要承载大量并发请求,单台服务器难以负荷,我使用多台Web服务器组成集群,前端使用Nginx负载均衡,将请求分散的打到 ...

  5. C# 创建text文本并写入数据

    /// <summary> /// 创建TXT文本并往里面写入数据 /// </summary> /// <param name="FileName" ...

  6. [开源] .Net ORM FreeSql 1.10.0 稳步向行

    写在开头 FreeSql 是 .NET 开源生态下的 ORM 轮子,转眼快两年了,说真的开源不容易(只有经历过才明白).今天带点干货和湿货给大家,先说下湿货. 认识我的人,知道 CSRedisCore ...

  7. E. Enemy is weak 解析(思維、離散化、BIT、線段樹)

    Codeforce 61 E. Enemy is weak 解析(思維.離散化.BIT.線段樹) 今天我們來看看CF61E 題目連結 題目 給一個數列\(a\),求有多少\((i,j,k)\),\(i ...

  8. CodeForces 1408G Clusterization Counting

    题意 给定 \(n\) 个点的无向带权完全图,边权为 \(1\sim\frac{n(n-1)}{2}\).对于满足 \(1\leq k\leq n\) 的每个 \(k\) 求出将原图划分成 \(k\) ...

  9. Java学习的第四十六天

    1.例8.1例类 import java.util.Scanner; public class Cjava { public static void main(String[]args) { Time ...

  10. P6064 [USACO05JAN]Naptime G

    最近做了多少道 usaco 了,连 FJ 都认识我了呀 题意描述 传送门 给你 \(N\) 段时间其中 \(B\) 段时间你要用来睡眠,再给你每个时间睡眠可获得的效用值 \(U_i\). 可惜的是你每 ...