条件语句/变量和基本数据类型-编程学习网

Python条件语句和基本数据类型

可变不可变：

可变类型：列表

不可变类型：字符串\数字\元祖

访问顺序：

1.顺序访问：字符串\列表\元祖

2.映射：字典（字典查询速度比列表快，但占内存高于列表）

3.直接访问：数字

存放元素个数：

容器类型（可以存放多个值）：列表\元祖\字典

原子（只能存放一个值）：数字\字符串

一.条件语句

1.if基本语句
   if 条件：
　　　　　内部代码块
　　　　　内部代码块
　　else:
　　　　....
　　print('...')

如果1==1，那么就输出 欢迎来到Python世界，否则输出 欢迎来到Java世界

if 1==1:
    print("欢迎来到Python世界")
else:
    print("欢迎来到Java世界")
　　

国际惯例代码块的缩进按照4个空格
#TAB键默认代指四个空格

if 1==1:
    print("欢迎来到Python世界")
print("end")

if 支持嵌套

if 1==1：

　　if 2==2:

　　　　print("欢迎来到Python世界")

　　else:

　　　　print("欢迎来到Java世界")

else:

　　print("欢迎来到C#世界")

if else 支持 if elif



inp = input('请输入会员级别：')

if inp == "高级会员"：

　　print('私人教练')

if inp == "铂金会员"：

　　print('有用教练')

else:

print('自己练吧')

补充：#pass关键字

if 1==1:

　　pass

else:

　　print('烧饼')

二.循环语句

　　死循环

　　import time

　　count = 0

　　while < 10:

　　　　print(count)

　　　　count = count + 1

　　print('123')

continue: 终止当前循环，开始下一次循环

break: 终止所有循环

习题：（if条件语句、while循环、奇数偶数）

使用while循环输入1 2 3 4 5 6 8 9 10

n = 1
while n < 101
　　if n == 7:
　　　　pass
　　else
　　　　print(n)
    n = n + 1
print ('----end----')

方法二:

count = 0
while count < 10:
　　if count == 7:
　　　　count = count + 1
　　　　continue
　　print （count）
count = count + 1

求1-100的所有数的和

n = 1
s = 0
while n < 101:
　　s = s + n
　　n = n + 1
print(s)

输出1-100内的所有奇数

n = 1
while n < 101:
　　temp = n % 2
　　if temp == 0:
　　　　pass
　　else:
　　　　print(n)
　　n=n+1
print('---end---')

输出1-100内的所有偶数

n = 1
while n < 101:
    temp = n % 2
    if n ==0:
　　　　print(n)
　　 else
　　　　pass

    n = n + 1
print('----end----')

求1-2+3-4+5…99的所有数的和

n = 1
s = 0
while n < 100:
　　temp = n % 2
　　n = n + 1
　　s = s + n
　　if n == 0:
　　　　print(s-n)
　　else:
　　　　print(s+n)
print(s)

用户登录（三次机会重试）

count = 0
while count < 3:
　　user = input('请输入账号')
　　pwd = input('请输入密码')
　　if user == 'asd' and pwd == '123':
　　　　print ('欢迎登陆')
　　　　Print ('.....')
　　　　break
　　else:
　　　　print ('密码错误')
　　count = count + 1

三.基本数据类型

一个字节=8位

1.字符串(str): 引号引起来事物部分为字符串，字符串里每一个组成部分为字符

字符串（str）常用功能：

移除空白
分割
长度
索引
切片

字符串一旦创建不可修改，一旦修改或者拼接，都会造成重新生成字符串

eg:name = "我是丢丢"

name = '我是丢丢'

　　name = '''我是丢丢'''

　　name = """我是丢丢"""

加法:

　　n1 = "alex"

　　n2 = "sb"

　　n3 = n1 + n2

　　n3 = "alexsb"

乘法：

　　n1 = "alex"

　　n2 = "n1 * 10"

a.首字母大写

text = “alex”
 v = text.capitalize()
print (v)

b.很多未知的对应边小写

text = "AlEx"
v1 = text.casefold()
print (v1)

c.空白未知填充，支持填一个字符，可有可无

text = "alex"
v = text.center(20,"*”)
print(v)

d.去字符串中寻找子序列出现的次数，可以设置起始位置及结束位置

text = "asdjkii"
v = text.count('i'，5 ，9)
print(v)

e.以什么什么结尾，以什么什么开头

text = "dream"
v = text.endswith('m')
print (v)


text = "dream"
v = text.startswith('d')
print (v)

f.从开始往后面找，找到第一个之后，获取其位置；前面：大于或后面：大于等于

text = "dream"

v = text.find('re')

print(v)

g.格式化，将一个字符串中的占位符替换为指定的值

text = 'i am {name},age{a}
print (text)
v = text.pormat(name='dream',a=19)
print (v)

h.格式化传入的值{"name":'dream',"a":19}

text = 'i am {name},age{a}'
v = text.format_map({"name":'dream',"a":19})
print(v)

i.字符串中是否只包含字母和数字

text = "hsjhj23"
v = text .isalnum()
print(v)

k.字符串中只包含字母

text = "hsdjhj"
v = text.isalpha()
print(v)

l.断句，20

text = "username\temail\tpassword\nconghui\t2271663109@qq.com\t156\nmengwan\t545265@qq.com\t456

v = text.expandtabs(20)

print(v)

m.判定当前输入的是否是数字

text = "123"
v1 = text.isdecimal()
v2 = text.isdigit()
print(v1,v2)

n.字母、数字、下划线：标识符 def class

a = "123"
v = a.isidentfire()
print(v)

o.当前输入是否是数字

text = "二"#1，②
v1 = text.isdecimal()         #十进制小数，用的次数较多
v2 = text.isdigit()           #包含特殊的①符号不支持中文
v3 = text.isnumeric()         #支持中文
print(v1,v2,v3)

p.是否存在不可显示的字符 \t:制表符 \n:换行

text = "hdsgjhk\tklj"
v = text.isprintable()
print(v)

q.判断是否全部是空格

text = "   "
v = text.isspace()
print(v)

r.判断是否是标题以及变成标题

text = “return True if all cased characters in S are uppercase and there is”
v = text.istitle()
print(v)  
v1 = text.title()

  #将首字母转换成大写


print(v1)
v2 = v1.istitle()
print(v2)

s.将字符串中的每一个元素按照指定分隔符进行拼接 **重要

text = "你是风儿我是沙”
print (text)
v = "——”.join(text)
print(v)

t.将字符置于左边或右边

text = "dream"
v = text.ljust(20,"*")
print(v)


text = "dream"
v = text.rjust(20,"*")
print(v)

u.判断是否全部是大小写或全部转换为大小写

text = "Dream"
v = text.islower()
v1 = text.lower()
print(v,v1)

text = "Dream"
v = text.isupper()
v1 = text.upper()
print(v,v1)

text = "dream"
v = text.lstrip()
print(v)               #左边加空白

text = "dream"
v1 = text.rstrip()
print(v1)               #右边加空白


text = "dream"
v2 = text.strip()
print(v2)                 #去除左右空白 移除\t  \n  移除指定字符

text = "dream"           # 将字符串分割为三份
v = text.partition('e')
print(v)


text = “dream”            #根据e进行分割，但匹配到的e自己拿不到
v = text.split('e',2)
print(v)

text = “dream”            #根据e从右边进行分割，但匹配到的e自己拿不到
v = text.rsplit('e',2)
print(v)

s.只能根据换行分割，true,false:是否保留换行

text = "hjkjkh\nhhksdlg\nhkhk"
v = text.splitlines(False)
print(v)

y.大小写转换

text = "dream"
v = text.swapcase()
print(v)

z.索引、下标，获取字符串中的某一个字符

text = "dream"
v = text[2]
print(v)

获取到e

#切片
text = "dream"
v = text[0:2]
print(v)

ab.获取当前字符串中由几个字符组成

text = "dream"
v = len(text)
print(v)

ac.for 变量名 in 字符串：

　　　　变量名（循环每个元素的变量名）

方法一
text = "2019年要做一只勤奋的猪"
index = 0
while index < len(text):
    v = text[index]
    print(v)
    index += 1
print("===")

方法二
text = "2019年要做一只勤奋的猪"
for zch in text:
　　print (zch)

ad.

text = "dream"
v = text.replace("ea","bbb",2)    #只替换前两个
print(v)

ae. range帮助创建连续的数字,通过设置步长来指定不连续

v = range(0，100，5)
for in item v:
　　print(item)

练习：将文字对应的索引打印出来

test = input ("<<<")
for item in range(0,len(test)):
print (item,test[item])

2.数字：没有双引号引起来，只写一个数字

int(整形)

int功能：

　　1.将字符串转换为数字

　　　　a = "123"

　　　　print（type(a),a）  #type  字符类型

　　　　b = int(a)

　　　　print (type(b),b)


　　　　num = "0011"
　　　　v = int(num,base=2)  #将字符串以二进制的方式转换
　　　　print(v)

""" 返回表示该当前数字的二进制至少用几位来表示 """  1字位节=8

　　　　age = 5
　　　　r = age.bit_length()   #bit_length :当前数字的二进制至少用几位来表示
　　　　print (r)

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

　　age = 13

　　a1 = 10

　　a2 = 20

加：a3 = a1 + a2

减：a3 = a1 - a2

乘：a3 = a1 * a2

　　a3 = 4**4 四次方

除：a3 = 100/10

　　a3 = 39 % 8 #获取39除以8得到的余数

补充：

　　39 / 8

　　a == 13

　　temp = a % 2

　　if temp == 0:

　　　　print("偶数")

　　else:

　　　　print("奇数")

3.列表（list）:有序，元素可以被修改

a.中括号括起来分割每个元素

b.列表中的元素可以是数字，字符串，列表，布尔值...所有的都能放进去（可以嵌套任何类型）

c.“集合”内部可以放置任何东西

d.可以通过索引取值、切片取值，切片的结果也是一个列表

print(li[2])

print(li[1:3])

e.for循环

for item in li:

　　print(item)

f.while循环

g.列表元素可以被修改(索引、切片)

h.删除

索引修改、删除
li[1] = 120
print (li)

li[1] = [11,112,23]
print(li)

li = ["age",1,2,"丢丢",["19",5],5]
del li[3]
print(li)

切片修改、删除
li[1,3]=[120,90]
print(li)

li = ["age",1,2,"丢丢",["19",5],5]
del li[1:3]
print(li)

i.支持in操作

li = ["age",1,2,"丢丢",["19",5],5]
v = 5 in li
print(v)

# 取19
li = ["age",1,2,"丢丢",["19",5],5]
v = li [4][1][0]
print(v)

g.转换：字符串转换列表

s = "shgjksdhvkhsdakhjlcd" ,内部使用for循环

s = "shgjksdhvkhsdakhjlcd"
new_li = list(s)
print(new_li)

列表转换成字符串：①需要自己写for循环一个一个处理（针对列表既有数字又有字符串的情况）

②列表中的元素只有字符串,直接使用字符串jion方法

①
li = [11, 22, 33, "alex"]
s = ""
for i in li:
    s = s + str(i)
print(s)
②

li = ["123", "dream"]
r = "".join(li)
print(r)

h.list类的一个对象

在原来值最后追加
li = [11,232,33,44]
li.append(5)
print(li)

[11,222,33,44,5]

i.clear清空列表

li = [11,22,33,44]
li.clear()
print(li)

j.copy 拷贝，浅拷贝

li = [11,22,33,44]
v = li.copy()
print(v)

k. count 计算元素出现的次数

def count(self, value):...

li = [11,22,33,44,22]
v = li.count(22)
print(v)

l. extend 扩展原列表，参数（interable）：可迭代对象

def extend(self, interable): ...

li = [11,22,33,44]
li.extend(["dream",22])
print（li）

[11,22,33,44,"dream",22]

m.index 根据值获取当前值索引位置（左边优先）

def index(self, sub, start=None, stop=None):

li = [11, 22, 33, 44, 22]
v = li.index(22,2,4)
print(v)

n.insert 在制定索引位置插入元素

def insert(self, index(索引), p_object):

li = [11, 22, 33, 44, 22]
li.insert(0,99)
print(li)

o.pop 删除某个值，并获取删除的值。未指定索引，默认情况下删除最后一个元素

def pop(self, index=None):

li = [11,22,33,44]
v = li.pop()
print(li)
print(v)

指定索引：
li = [11,22,33,44]
v = li.pop(1)
print(li)
print(v)

p. remove 删除列表中的指定值 ps:pop ; remove ; del li[0] ; del li[7:9] ; clear

li = [11,22,33,44]7:
li.remove(33)
print(li)

q. reverse 将当前列表进行翻转

def reverse(self):...

li = [22,11,44,33,22]
li.reverse()
print(li)

r. sort

从小到大
li = [11,22,33,44,22]
li.sort()
print(li)

[11,22,22,33,44]
从大到小：

li = [11,22,33,44,22]
li.sort(reverse=True)
print(li)

[44,33,22,22,11]

创建列表：

name_list = ['alex','seven','eric']     
或
name_list = list(['alex','sevev','eric'])  #通过list类创建的对象

基本操作：

索引
切片
追加
删除
长度
切片
循环
包含

4.布尔值

真或假

1或0

None "" () [] {} 0 ==>False

5.元祖(tuple)：元素不可被修改，不能被增加或者删除

创建元祖：　（一般写元祖的时候，推荐在最后加逗号）

　ages = (11,22,33,44,55，)
　或
　ages = tuple((11,22,33,44,55，))

基本操作：

索引

tu = (11,22,33,44,)
v = tu[1]
print(v)

切片

tu = (11,22,33,44,)
v = tu[1:3]
print(v)

长度
包含
可迭代对象:字符串、列表、元祖、

tu = (11,22,33,44)
for item in tu:
print(item)

利用可迭代对象功能可以进行转换

tu = ("my","dream")
v = "".join(tu)
print(v)

元祖的一级元素不能被修改/删除/增加

tu = (111, "dream", (11, 22,), [(33, 44)], True, 33, 44)
tu[3][0] = 567
print(tu)

a. tu.count(22),获取指定元素在元祖中出现的次数

tu = (11, 22, 33, 44, 22,)
v = tu.count(22)
print(v)

b. tu.index(),获取某一个值进行索引

tu = (11, 22, 33, 44, 22,)
v = tu.index(22)
print(v)

6.字典（无序）(dict)：重要：keys() values() items() get updata

创建字典：

　a.基本结构

person = {"name": "Mr.wu", 'age'：18}   #键值对
或
person = ({"name":"Mr.wu", 'age':18})

常用操作：

索引
新增
删除
键、值、键值对
循环
长度

PS:循环，range，continue和break

b.字典的value可以是任何值

infor = {
    "k1": 18,
    "k2": True,
    "k3": [
        11,
        22,
        33,
        {
            "kk1": "vv1",
            "kk2": "vv2",
            "kk3": (11, 22)

        }
    ],
    "k4": (11, 22, 33, 44,)

}
print(infor)

c.布尔值、列表、字典不能作为字典的Key

infor = {
    True:"v1",
    "k0":"v2",
    "k1":"dream",
    (11,22):"dg"
}
print(infor)

d.字典是无序的

f.索引方式找到指定元素

info = {
    2: 18,
    "k2": True,
    "k3": "dream",
    "k4":[11,22,33,(1,22)]
}
v = info["k4"][3][0]
print(v)

g.字典支持del删除

info = {
    2: 18,
    "k2": True,
    "k3": "dream",
    "k4": [
        11,
        22,
        33,
        (
            1,
            22
        )
    ]
}
del info ["k4"]
print(info)

h.字典可以进行for循环，默认进行循环时根据k循环

info = {
    2: 18,
    "k2": True,
    "k3": "dream",
    "k4": [
        11,
        22,
        33,
        (
            1,
            22
        )
    ]
}
for k,v in info.items():
   print(k,v)

i.根据序列，创建字典，并指定同意的值（formkeys）

dict = {
    "k1":"v1"
}
v = dict.fromkeys(["k1",123,"999"],123)
print(v)

j.根据key获取值，key不存在时,可以指定默认值（None） #get

dic = {
    "k1":"v1"
}
v = dic.get("k1",1111)
print(v)

h.删除并获取值（pop）

dic = {
    "k1": "v1",
    "k2": "v2"
}
k,v = dic.popitem()   
print(dic, k,v)               #随机删除

dic = {
    "k1": "v1",
    "k2": "v2"
}
v = dic.pop("k1")
print(dic,v)                   #删除指定的值

dic = {
    "k1": "v1",
    "k2": "v2"
}
v = dic.pop("k111"，90)
print(dic,v)                    #指定值不存在时，可以是任意值

i.设置值，已经存在，不设置，获取当前key对应的值

不存在，设置，获取当前key对应的值（setdefault）

dic = {
    "k1": "v1",
    "k2": "v2"
}
v = dic.setdefault("k1",123)
print(dic,v)             #存在

dic = {
    "k1": "v1",
    "k2": "v2"
}
v = dic.setdefault("k122",123)
print(dic,v)               #不存在

j.已经存在的覆盖掉，不存在的更新（update）

updata调用方式1：
dic = {
    "k1": "v1",
    "k2": "v2"
}
dic.update({"k1":1111,"k3":222})
print(dic)

update调用方式二：

dic = {
    "k1": "v1",
    "k2": "v2"
}
dic.updata(k1=123,k2=369,k5="sgj")
print(dic)

集合

1.不同元素组成

2.无序

3.集合中元素必须是不可变类型(数字/字符串/元祖，2)

集合关系运算交差并集

#交集
python_1 = ['lcg','szw','zjw']
linux_1 = ['lcg','szw']
python_and_linux_1 = []
for p_name in python_1:
    if p_name in linux_1:
        python_and_linux_1.append(p_name)
print(python_and_linux_1)

#方法二：
python_1 = ['lcg','szw','zjw']
linux_1 = ['lcg','szw']
p_s = set(python_1)
l_s = set(linux_1)
print(p_s,l_s)
print(p_s.intersection(l_s))    #等于：print(p_s&l_s)

#并集

python_1 = ['lcg','szw','zjw']
linux_1 = ['lcg','szw']
p_s = set(python_1)
l_s = set(linux_1)
print(p_s,l_s)
print(p_s.union(l_s))  #等于print(p_s|l_s)

#差集 （存在于左边集合不存在于右边集合）
python_1 = ['lcg','szw','zjw']
linux_1 = ['lcg','szw']
p_s = set(python_1)
l_s = set(linux_1)
print(p_s,l_s)
print(p_s.difference(l_s))
#等于print('差集和',p_s-l_s)

#交叉补集
python_1 = ['lcg','szw','zjw']
linux_1 = ['lcg','szw']
p_s= set(python_1)
l_s = set(linux_1)

print(p_s,l_s)
print('交叉补集',p_s.symmetric_difference(l_s))
#等于print(p_s^l_s)

#差集更新
python_1 = ['lcg', 'szw', 'zjw']
linux_1 = ['lcg', 'szw','sb']
p_s = set(python_1)
l_s = set(linux_1)
print(p_s,l_s)
#p_s = p_s - l_s
p_s.difference_update(l_s)
print(p_s)

#没有交集返回True 有交集返回False
s1 = {1,2}
s2 = {3,5}
print(s1.isdisjoint(s2))

s1 = {1,2}
s2 = {1,2,3}
print(s1.issubset(s2))   #s1是s2的子集
#print(s2.issubset(s1))   #s2是s1的子集

s1 = {1,2}
s2 = {1,2,3}
s1.update(s2)    #更新多个值
print(s1)

#不可变集合
s = frozenset('hello')
print(s)

#简单去重
names = ['alex','alex','zch']
s = set(names)
print(s)

#变列表
names= ['alex','alex','zch']
s = set(names)
names = list(s)
print(names)

#相当于：
names= ['alex','alex','zch']
names=list(set(names))
print(names)

百分号方式

tpl = "i am %s" % "alex"
 
tpl = "i am %s age %d" % ("alex", 18)
 
tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
 
tpl = "percent %.2f" % 99.97623      #打印浮点数，默认保留两位小数点
 
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
 
tpl = "i am %.2f %%" % {"pp": 123.425556, }  #打印百分比

format方式

[[fill]align][sign][#][0][width][,][.precision][type]

fill 【可选】空白处填充的字符
align 【可选】对齐方式（需配合width使用）

<，内容左对齐
>，内容右对齐(默认)
＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即使：符号+填充物+数字
^，内容居中

sign 【可选】有无符号数字
- +，正号加正，负号加负；
- -，正号不变，负号加负；
- 空格，正号空格，负号加负；
# 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
，【可选】为数字添加分隔符，如：1,000,000
width 【可选】格式化位所占宽度
.precision 【可选】小数位保留精度
type 【可选】格式化类型
- 传入” 字符串类型 “的参数
  - s，格式化字符串类型数据
  - 空白，未指定类型，则默认是None，同s
- 传入“ 整数类型 ”的参数
  - b，将10进制整数自动转换成2进制表示然后格式化
  - c，将10进制整数自动转换为其对应的unicode字符
  - d，十进制整数
  - o，将10进制整数自动转换成8进制表示然后格式化；
  - x，将10进制整数自动转换成16进制表示然后格式化（小写x）
  - X，将10进制整数自动转换成16进制表示然后格式化（大写X）
- 传入“ 浮点型或小数类型 ”的参数
  - e，转换为科学计数法（小写e）表示，然后格式化；
  - E，转换为科学计数法（大写E）表示，然后格式化;
  - f ，转换为浮点型（默认小数点后保留6位）表示，然后格式化；
  - F，转换为浮点型（默认小数点后保留6位）表示，然后格式化；
  - g，自动在e和f中切换
  - G，自动在E和F中切换
  - %，显示百分比（默认显示小数点后6位）

常用格式化：

tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
  
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex']) #代表传入的值为列表
  
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
  
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
  
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
  
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})#代表传入值为字典
  
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
  
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
  
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
  
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
  
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
 
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 #二进制    八进制    16进制   显示百分比
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
 
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

1.python基础

①：第一句Python

　　- 后缀名可以是任意的？

　　- 导入模块时，如果不是.py文件，可能会报错

　　==》以后文件后缀名是 .py

②：两种执行方式

　　python解释器 py文件路径

　　python 进入解释器：

　　　　实时输入并获取到执行结果

③：解释器路径

window linux 系统中：

D:\python35\python 2.py

python 2.py

linux系统中:

文件名：

　　./2.py

文件内部：

解释器路径

#!/usr/bin/env python 声明当前使用的是哪个Python解释器

编码

# -*- coding:utf8 -*-  告诉python解释器帮我们怎么编码文件

ascill  　　00000000        

&       　　00000001

unicode 　　0000000000000000+     至少16位

&　　　　　　0000000000000001      浪费内存空间

utf8       能用多少表示就用多少表示  中文占3个字节

&   　　　　00000001

gbk  中文占两个字节


python3 无需关注编码

oython2 每个文件中，只要出现中文，头部必须加# -*- coding:utf8 -*-

⑤：执行一个操作

　　提醒用户输入：用户名和密码

　　获取用户名和密码，检测：用户名=root 密码=root

　　正确：登录成功

　　错误：登录失败

　　input的用法

#永远等待，直到用户输入一个值，就会将输入的值赋给n,n代指用户输入的内容，即变量
#变量定义的规则：
　　a.只能由 字母、数字、下划线的任意组合；
　　b.变量名的第一个字符不能是数字；
　　c.Python关键字不能声明为变量。
　　【'and', 'as', 'assert', 'class', 'break', 'continue', 'else', 'finally', 'for', 'from',
'import', 'i', 'global', 'is', 'pass', 'print', 'return', 'while', 'with', 'yield', 'try'】


　　n1=input('请输入用户名:')  #n1用来接收input里面输入的值/ 等待用户输入

　　n2=input('请输入密码：')

　　print(n1)

　　print(n2)

#如果将字符串转换成数字  new_inp = int (inp)

文章详情

条件语句/变量和基本数据类型