第一模块：Python基础(二)

zoukankan html css js c++ java

第一模块：Python基础(二)
@
目录
1.变量
常量
2.用户交互和注释
程序交互
注释
3.基本的数据类型
什么是数据类型
数字
int(整型)
long(长整型)
浮点型
复数
字符串
字符串的操作
布尔型(bool)
格式化输出
运算符
算术运算
比较运算符
赋值运算：
逻辑运算
身份运算
while 循环
for 循环
if...else
1.变量

变量用于存储要在计算机程序中引用和操作的信息。它们的唯一目的是在内存中标记和存储数据。然后可以在整个程序中使用这些数据。变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

声明变量
```
name = "nepoleon"
```
定义变量的规则
- 变量名只能是字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- 以下关键字不能声明为变量名['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
命名规则
- 驼峰式
  MyName = "zzk" 每个单词首字母大写
- 下划线
  my_name = "zzk" 单词用下划线连接
- 变量名，不要为中文，拼音，或者名字过长，词不达意等
多个变量赋值
```
a = b = c = 3 
```
多个变量指定多个变量
```
a,b,c = 1,"tom",666
```
常量

常量即指不变的量，如pai 3.141592653..., 或在程序运行过程中不会改变的量

在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量
```
NUMERBER = 56
```
在c语言中有专门的常量定义语法，const int count = 60;一旦定义为常量，更改即会报错

2.用户交互和注释

程序交互

读取用户输入
```
name = input("What is your name?")
print("My name is",name)
```
让用户输入多个信息
```
name = input("What is your name?:")
age = input("Your age:")
hometown = input("Where is your hometown?")

print('''My name is %s,
my age is %s,
my hometown is %s''' %(name,age,hometown))
```
输出的结果为：
```
My name is,zk,
my age is 22,
my hometown is anhui
```
注释

代码注释分单行和多行注释，单行注释用#，多行注释可以用三对双引号""" """
```
def subclass_exception(name, parents, module, attached_to=None):
    """
    Create exception subclass. Used by ModelBase below.

    If 'attached_to' is supplied, the exception will be created in a way that
    allows it to be pickled, assuming the returned exception class will be added
    as an attribute to the 'attached_to' class.
    """
    class_dict = {'__module__': module}
    if attached_to is not None:
        def __reduce__(self):
            # Exceptions are special - they've got state that isn't
            # in self.__dict__. We assume it is all in self.args.
            return (unpickle_inner_exception, (attached_to, name), self.args)

        def __setstate__(self, args):
            self.args = args

        class_dict['__reduce__'] = __reduce__
        class_dict['__setstate__'] = __setstate__

    return type(name, parents, class_dict)
```
代码注释原则:
- 不用全部把代码都注释，只需要把重要的，或者不好理解的注释一下
- 注释可以是中文，英文，但不要是拼音
3.基本的数据类型

什么是数据类型

我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。

数字

int(整型)

在32位机器上，整数的位数为32位，取值范围为-2³¹～ 2³¹-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2⁶³～2⁶³-1，即-9223372036854775808～9223372036854775807

long(长整型)

在Python3里不再有long类型了，全都是int
```
>> a = 2**64
>> type(a)

>>  <class 'int'>
```
浮点型

浮点数是属于有理数中某特定子集的数的数字表示，在计算机中用以近似表示任意某个实数。具体的说，这个实数由一个整数或定点数（即尾数）乘以某个基数（计算机中通常是2）的整数次幂得到，这种表示方法类似于基数为10的科学计数法。

python的浮点数就是数学中的小学，(无限循环小数或者有限小数)

为什么要叫做float浮点型？

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，
一个浮点数的小数点位置是可变的，比如，
1.23109和12.3108是相等的。
浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代：
1.23*109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的而浮点数运算则可能会有四舍五入的误差。

复数

复数complex是由实数和虚数组成的

要了解复数，其实关于复数还需要先了解虚数。虚数(就是虚假不实的数):平方为复数的数叫做虚数。

复数是指能写成如下形式的数a+bi，这里a和b是实数，i是虚数单位(即-1开根)。在复数a+bi中，a称为复数的实部，b称为复数的虚部(虚数是指平方为负数的数)，i称为虚数单位。

当虚部等于零时，这个复数就是实数；当虚部不等于零时，这个复数称为虚数。

注，虚数部分的字母j大小写都可以。

字符串

字符串是有有序的，不可变的
在python中加了引号的都认为是字符串
```
name = "nep"  #  双引号
age = "22"    # 字符串
n_age = 22    # int
hometown = ''' Anhui '''   #三引号
job = 'vfx'   # 单引号
```
单引号，双引号没有区别，多行注释必须用三引号

转译
- 字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l hf'
- unicode字符串与r连用必需在r前面，如name＝ur'l hf'
字符串的操作
```
s = "hello word"
#索引
s = 'hello'
>>> s[1]
'e'
>>> s[-1]
'o'
#切片
>>> s = 'abcdefghigklmn'
>>> s[0:7]
'abcdefg'
>>> s[7:14]
'higklmn'
>>> s[:7]
'abcdefg'
>>> s[7:]
'higklmn'
>>> s[:]
'abcdefghigklmn'
>>> s[0:7:2]
'aceg'
>>> s[7:14:3]
'hkn'
>>> s[::2]
'acegikm'
>>> s[::-1]
'nmlkgihgfedcba'
len(s)      # 字符串的长度
s.swapcase()    # 大小写互换
s.capitalize()  # 首字母大写
s.casefold()    #全部统一都是小写
s.center()      # 居中显示 例如 print(s.center(30,"#"))
s.count()       # 统计某个字符的个数，空格也算是一个字符， s.count("o",0,5) 0-5之间"o"的个数。
s.endswith()    # 判断以什么结尾，返回 True/False
s.strip()       #去掉字符串的空格
s.lstrip()    # 去掉左侧空格
s.rstrip()    #去掉右侧的空格
isdigit()  #判断是否是数字
s.title()  # 每个单词的首字母大写
islower()  #判断是否是全部小写

isupper() #判断是否是全部大写

lower()  #全部转换为小写

upper() #全部转换为大写

isspace()  #判断是否是全都是空格

istitle() #判断是否是标题（首字母大写）  
```
expandtabs() 扩展tab键，前提是字符串里有tab键
```
a = "a	b	c"            # 	 就是tab键
print(a.expandtabs(8))  # 每个字符之间8个空格
```
find() 查找字符的索引位置，如果是负数，代表查找失败,find()也可以查起始
```
s = "Hello,word"
s.find("o",0,5)
```
index() 返回索引值与find()的区别
```
s.index("a")   # a 不在 字符串s里面，返回报错，find()没有不会报错，输出-1
```
format() 字符串格式化
```
s14 = "my name is {0},i am {1} years old"
s14.format("Tom",23)
# 还可以这样
s15 = "my name is {name},i am {years} years old"
s15.format(name = "zk","years" = 22)
```
join() 接两个字符串
```
a = "-"
name = ["tom","san","kite"]
s = "abcde"
print(a.join(name))   # 输出 tom-san-kite

print(a.join(s))  # a-b-c-d-e
```
ljust() 左侧开始对齐到多少位
```
s = "hello word"
s.ljust(30,"-")   # 左往右 30个字符，后面都是 - 
```
replace() 替换字符
```
a = "hello word"
a.replace("o","-")  #  全部替换 o
a.replace("o","-",1)  # 给第一个 o 替换
```
split() 分割，返回列表。

布尔型(bool)

布尔类型很简单，就两个值，一个True(真)，一个False(假), 主要用记逻辑判断
```
a = 3 
b =5
a < b   # 成立 就是True
True
a > b  # 不成立就是 False
False
```
bool型只有两个值：True和False

之所以将bool值归类为数字，是因为我们也习惯用1表示True，0表示False。

格式化输出

以下为不同方法的格式化
- input做用户输入， +连接2个字符串
```
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: Nepoleon Chou

name = input ("name:")
age = input("age:")
job = input("job:")

info = '''
--------------info of '''+ name +''''-----------------
Name: ''' + name + '''
Age: ''' + age + '''
Job:'''  + job

print(info)
```
- 上面写法太繁琐，我们可以用%s,%d做格式化输出，可以这些写：
```
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: Nepoleon Chou

# 格式化输出 %s s代表string
# %d 代表只能输入数字  %f 浮点
name = input ("name:")
age = int(input("age:"))
job = input("job:")
salary = input("salary:")

info = '''
--------------info of %s-----------------
Name: %s
Age:  %d     
job:  %s
Salary: %s
 '''% (name,name,age,job,salary)
print(info)
```
- 还可以用.format来格式化输出，以后用的比较多：
```
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: Nepoleon Chou
name = input ("name:")
age = int(input("age:"))
job = input("job:")
salary = input("salary:")
info2 = '''
----------------info of {_name}------------
Name = {_name}
Age = {_age}
job = {_job}
Salary = {_salary}

''' .format(_name=name,
            _age=age,
            _job=job,
            _salary=salary)
print(info2)
```
```
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: Nepoleon Chou
name = input ("name:")
age = int(input("age:"))
job = input("job:")
salary = input("salary:")
info3 = '''
---------------info of {0}----------
Name = {0}
Age = {1}
Job = {2}
Salary = {3}
''' .format(name,age,job,salary)
print(info3)
```
运算符

计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算，今天我们暂只学习算数运算、比较运算、逻辑运算、赋值运算

算术运算

比较运算符

赋值运算：

逻辑运算

身份运算

while 循环

Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。
当判断条件假false时，循环结束。

使用while猜年龄：
```
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: Nepoleon Chou

# 猜年龄 只能猜3次，3次之后就退出


Age_of_Nepoleon = 24

count = 0                                        #0开始计数
while True:                                      #当条件满足
    if count == 3:                               #如果输入3次
        break
    count += 1
    guess_age = int(input("Age_of_Nepoleon:"))
    if guess_age == Age_of_Nepoleon:
        print("yes,You are Right!")
        break
    elif guess_age > Age_of_Nepoleon:
        print("No,it's too bigger")
    else:
        print("No,it's too smaller")
        
```
优化以上代码：
```
Age_of_Nepoleon = 24

count = 0
while count<3:

    count += 1
    guess_age = int(input("Age_of_Nepoleon:"))
    if guess_age == Age_of_Nepoleon:
        print("yes,You are Right!")
        break
    elif guess_age > Age_of_Nepoleon:
        print("No,it's too bigger")
    else:
        print("No,it's too smaller")

else:
    print("you have tried much time...breakDown")
```
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：
```
# continue 和 break 用法
 
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print i         # 输出双数2、4、6、8、10
 
i = 1
while 1:            # 循环条件为1必定成立
    print i         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break
```
无限死循环
如果条件判断语句永远为 true，循环将会无限的执行下去，如下实例：
```
#!/usr/bin/env python

count = 0
while True:
    print("你好",count)
    count+=1
```
for 循环
```
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: Nepoleon Chou

for i in range(0,10,2):    #每2个输出一个
    print("loop",i)
```
continue ，break来跳过循环，continue是跳过本次循环，berak结束所有的循环。
```
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: Nepoleon Chou

for i in range(0,10):    #每2个输出一个
    if i <7:
        continue      #遇到小于7的直接跳过去
    elif i == 9:
        break         #等于9的时候跳出循环
    print("loop",i)
```
if...else

if 条件:
满足条件执行代码
elif 条件:
上面的条件不满足就走这个
elif 条件:
上面的条件不满足就走这个
elif 条件:
上面的条件不满足就走这个
else:
上面所有的条件不满足就走这段

输入密码时，如果想要不可见，需要利用getpass 模块中的 getpass方法，即：
```
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author: Nepoleon Chou

import getpass
# 密文模块

username = input('username:')
password = getpass.getpass('password:')        #密文
#password = input('password:')         #明文

_username = 'Nepoleon'
_password = '1234'

if _username == username and _password == password:                #如果输出的用户名和密码跟用户设置的用户名和密码匹配
    print('Welcome user {name} login...' .format(name=username))
else:
    print('Invalid username or password!')

print(username,password)
```
查看全文

相关阅读:
Pycharm新建第一个Django项目
 Django的MTV模型
 TCP Retransmission 连接超时
 linux系统参数调优
 企业网站架构
 基于centos7,python3.7新建第一个Django项目
 运维日常错误总结（docker)
docker常用技巧
 DHCP服务部署
 ssh远程登录故障解决方案