url.py

from django.contrib import admin

from django.urls import path,include

from app1.views import *

from app2.views import *

from app3.views import *

from app4.views import *

urlpatterns = [

    path('admin/', admin.site.urls),

    path('app3/', include('app3.urls')),

    path('create/',orm),

    path('many/',many_orm),

    path('get/',get_orm),

    path('all_obj/',all_obj),

    path('orm/',orms)

model 基础操作

1.1创建Meta源信息

from django.db import models

class UserInfo(models.Model):

    username=models.CharField(max_length=32)

    password=models.CharField(max_length=32)

    class Meta:

        #1数据库生成的表名称 默认app名称+下划线+类名

        db_table='table_name'  #自己指定创建表名

        #Django admin 中显示的表名称

        verbose_name='user'  #在Django admin后台显示时表名是users

        #3verbose_name_plural='user'

        verbose_name_plural='user' #若果这个字段也是user那么4中表名才显示user

        #4联系唯一索引

        unique_together=(('name'))

        # 5 联合索引 (缺点是最左前缀，写SQL语句基于password时不能命中索引，查找慢)

        # 如：select * from tb where password = ‘xx’ 就无法命中索引

        index_together=[

            ('name')

        ]

1.2常用字段

class UserGroup(models.Model):

    uid=models.AutoField(primary_key=True)

    name=models.CharField(max_length=32,null=True,blank=True)

    email=models.EmailField(max_length=32)

    text=models.TextField()

    ctime = models.DateTimeField(auto_now_add=True)  # 只有添加时才会更新时间

    uptime = models.DateTimeField(auto_now=True)  # 只要修改就会更新时间

    ip1 = models.IPAddressField()  # 字符串类型，Django Admin以及 ModelForm中提供验证 IPV4 机制

    ip2 = models.GenericIPAddressField()  # 字符串类型，Django Admin以及 ModelForm中提供验证 Ipv4和Ipv6

    active = models.BooleanField(default=True)

    data01 = models.DateTimeField()  # 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ

    data02 = models.DateField()  # 日期格式 YYYY-MM- DD

    data03 = models.TimeField()  # 时间格式 HH:MM[:ss[.uuuuuu]]

    age = models.PositiveIntegerField()  # 正小整数 0 ～ 32767

    balance = models.SmallIntegerField()  # 小整数 -32768 ～ 32767

    money = models.PositiveIntegerField()  # 正整数 0 ～ 2147483647

    bignum = models.BigIntegerField()  # 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

    user_type_choices = (

        (1, "超级用户"),

        (2, "普通用户"),

        (3, "普普通用户"),

    )

    user_type_id = models.IntegerField(choices=user_type_choices, default=1)

1.3参数

    null=True    #数据库字段是否可以为空

    blank=True    #表单验证可以为空

    default=True   #数据库中字段的默认值

    parmary_key=True  #数据库中的字段是为主键

    db_index=True      #数据库中字段是否可以建立索引

    unique=True       #数据库字段是否可以建立唯一属性

2.一对多

2.1一对多基本的增删改查

2.1.1 models.py

from django.db import models

class UserInfo(models.Model):

    name=models.CharField(max_length=64,unique=True)

    ut=models.ForeignKey(to='UserType',on_delete=models.CASCADE)

class UserType(models.Model):

    type_name=models.CharField(max_length=64,unique=True)

2.1.2 views.py

from django.shortcuts import HttpResponse

from .models import *

def orm(request):

    1.创建

    创建数据方法一

    UserInfo.objects.create(name='roo',ut_id=1)

    创建数据库方法二

    users=UserInfo(name='root',ut_id=2)

    users.save()

    创建数据库方法三

    dict={'name':'r','ut_id':'1'}

    UserInfo.objects.create(**dict)

    删除

    UserInfo.objects.all().delete()  #删除所有

    UserInfo.objects.filter(name='r').delete()  #删除指定

    修改

    UserInfo.objects.all().update(ut_id=1)

    UserInfo.objects.filter(name='ro').update(ut_id=2)

    查找

    4.1正向查找

    user_obj.ut.type_name

    print(UserInfo.objects.get(name='ro').ut.type_name)

    print(UserInfo.objects.filter(ut__type_name='学生'))

   4.2反向查找

    type_obj.user_info_set.all()

    print(UserType.objects.get(type_name='学生').userinfo_set.all())

    print(UserType.objects.get(type_name='老师').userinfo_set.filter(name='ro'))

    return HttpResponse('ok')

一对多查找更多操作

2.2.1 models.py

from django.db import models

class UserType(models.Model):

    user_type_name=models.CharField(max_length=32)

    def __str__(self):

        return self.user_type_name   #只有加上这个,Django admin才会显示表名

class User(models.Model):

    username=models.CharField(max_length=32)

    pwd=models.CharField(max_length=64)

    ut=models.ForeignKey(

        to='UserType',

        to_field='id',

        on_delete=models.CASCADE,

        related_query_name = 'a',

    )

# 1、反向操作时，使用的连接前缀，用于替换【表名】

# 如： models.UserGroup.objects.filter(a__字段名=1).values('a__字段名')

        #2丶反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.b_set.all()

        # 使用时查找报错

        # related_name='b',

2.2.2 views.py

from django.shortcuts import render,HttpResponse

from .models import *

def many_orm(request):

    1.正向查找

    1.1 正向查找user表用户名

    print(User.objects.get(username='xiaowang').username)

    xiaowang

    1.2正向跨表查找用户类型

    print(User.objects.get(username='xiaowang').ut.user_trpe_name)

    老师

    print(User.objects.all().values('ut__user_type_name','username'))

    <QuerySet [{'ut__user_trpe_name': '老师', 'username': 'xiaowang'}, {'ut__user_

    type_name': '学生', 'username': 'wangsai'}]>

    2.反向查找

    2.1【表名_set】 反向查找user表中用户类型为老师的所有用户

    print(UserType.objects.get(user_trpe_name='老师').user_set.all())

    <QuerySet [<User: User object (1)>]>

    2.2【a__字段名】反向查找user表中张三在UserType表中的类型:(<[UserType:老师

    >])

    print(UserType.objects.filter(a__username='xiaowang'))

    <QuerySet [<UserType: 老师>]>

    2.3双下划线跨表反向查找

    print(UserType.objects.all().values('a__username','user_type_name'))

    <QuerySet [{'a__username': 'xiaowang', 'user_type_name': '老师'}, {'a__username': 'wangsai', 'user_type_name': '学生'}]>

    #3自动创建User表和UserType表中的数据

    '''

    user_type = [{'user_type_name':'student'},{'user_type_name':'teacher'},]

    for type_dict in user_type:

        UserType.objects.create(**type_dict)

    for user_dic in username:

        User.objects.create(**user_dic)

    '''

    return HttpResponse('yes')

2.3 一对多使用values和values_list结合双下划线跨表查询

from django.shortcuts import HttpResponse

from .models import *

#一对多使用values和values_list结合双下划线跨表查询

def get_orm(request):

    第一种: values----获取的内部是字典  拿固定列数

    1.1正向查找 ： 使用ForeignKey字段名ut结合双下划线查询

    suts=User.objects.filter(username='xiaowang').values('username','ut__user_type_name')

    print(suts)

    <QuerySet [{'username': 'xiaowang', 'ut__user_type_name': '老师'}]>

    1.2反向查找:使用ForeignKey的related_query_name='a',的字段

    obj=UserType.objects.all().values('user_type_name','a__username')

    print(obj)

    <QuerySet [{'user_type_name': '老师', 'a__username': 'xiaowang'}, {'user_type_name': '学生', 'a__username': 'wangsai'}]>

    第二种 : values_list-----获取的是元祖  拿固定列数

    1.1 正向查找 ：使用ForeignKey字段名ut结合双下划线查询

    stus=User.objects.filter(username='xiaowang').values_list('username','ut__user_type_name')

    print(stus)

    <QuerySet [('xiaowang', '老师')]>

    1.2反向查找

    utype=UserType.objects.all().values_list('user_type_name','a__username')

    print(utype)

    <QuerySet [('老师', 'xiaowang'), ('学生', 'wangsai')]>

    return HttpResponse('ok')

2.3 一对多ForeignKey可选参数

to      要进行关联的表名

to_field-None      要关联的表中的字段名称

on_delete=None     #当删除关联表的数据时，当前表与其无关联的行的行为

models.CASCADE      删除关联数据时，与之关联也删除

models.DO_NOTHING   删除关联数据，引发错误IntegrityError

models.PROTECT  删除关联数据，引发错误ProtectedError

models.SET_NULL   删除关联数据，与之关联的值设置为null (前提FK字段需要设置为空)

models.SET_DRFAULT   删除关联数据，与之关联的值设置为默认值

models.SET    #删除关联数据,

4.related_name=None,  #反向操作是，使用的字段名，用于代替【表名_set】如obj.表名_set.all()

在做自关联时必须指定此字段,防止查找冲突

5.delated_query_name=None  #反向操作是,使用的连接前缀，用于替换【表名】

models.UserGroup.objects.filter(表名__字段名1).values('表名__字段名')

3.Django 多对多表结构操作

3.1 第一种： ManyToManyField

from django.db import models

#自己不创建第三张表，有m2m字段：根据queryset对象增删改查(推荐)

class UserInfo(models.Model):

    username=models.CharField(max_length=32)

class UserGroup(models.Model):

    group_name=models.CharField(max_length=64)

    user_info=models.ManyToManyField(to='UserInfo',related_query_name='m2m')

3.2查询

    user_info_obj=UserInfo.objects.get(username='zhangsan')

    # print(user_info_obj)

    #zhangsan

    user_info_objs=UserInfo.objects.all()

    # print(user_info_objs)

    #<QuerySet [<UserInfo: zhangsan>, <UserInfo: lisi>, <UserInfo: wangwu>]>

    group_obj=UserGroup.objects.get(group_name='group_python')

    # print(group_obj)

    #group_python

    group_objs=UserGroup.objects.all()

    # print(group_obj)

    #<QuerySet [<UserGroup: group_python>, <UserGroup: group_linux>, <UserGroup:group_mysql>]>

    添加  ：正向

    group_obj.user_info.add(user_info_obj)

    group_obj.user_info.add(*user_info_objs)

    删除 ：正向

    group_obj.user_info.remove(user_info_obj)

    group_obj.user_info.remove(*user_info_objs)

    添加 ：反向

    user_info_obj.usergroup_set.add(group_obj)

    user_info_obj.usergroup_set.add(*group_objs)

    删除 ：反向

    user_info_obj.usergroup_set.remove(group_obj)

    user_info_obj.usergroup_set.remove(*group_objs)

    查找正向

    print(group_obj.user_info.all())   #查找group_python组中所有的用户

    查找反向

    print(user_info_obj.usergroup_set.all())

    查找用户张三属于哪个组

    <QuerySet [<UserGroup: UserGroup object (1)>]>

    双下划线 正向 反向查找

    正向：从用户组表中查找zhangsan属于哪个用户组：[<UserGroup: group_python>]

    print(UserGroup.objects.filter(user_info__username='zhangsan'))

    <QuerySet [<UserGroup: UserGroup object (1)>]>

    反向 ：从用户表中查询group_python组中有哪些用户：related_query_name='m2m'

    print(UserInfo.objects.filter(m2m__group_name='group_python'))

    <QuerySet [<UserInfo: UserInfo object (1)>]>

    return HttpResponse('ok')

# 自动创建UserInfo表和UserGroup表中的数据

 '''

      user_list = [{'username': 'zhangsan'},

                     {'username': 'lisi'},

                     {'username': 'wangwu'}, ]

        group_list = [{'group_name': 'group_python'},

                      {'group_name': 'group_linux'},

                      {'group_name': 'group_mysql'}, ]

        for c in user_list:

            UserInfo.objects.create(**c)

        for l in group_list:

            UserGroup.objects.create(**l)

      '''

3.2 第二种： 自己创建第三张表

自己创建第三张关系表，无 m2m 字段，自己链表查询

3.2.1models.py

#表1：主机表

class Host(models.Model):

nid = models.AutoField(primary_key=True)

hostname = models.CharField(max_length=32,db_index=True)

#表2：应用表

class Application(models.Model):

name = models.CharField(max_length=32)

#表3：自定义第三张关联表

class HostToApp(models.Model):

hobj = models.ForeignKey(to="Host",to_field="nid")

aobj = models.ForeignKey(to='Application',to_field='id')

# 向第三张表插入数据，建立多对多外键关联

HostToApp.objects.create(hobj_id=1,aobj_id=2)

3.3 多对多双下划线查找

from django.shortcuts import HttpResponse

from app01 import models

def orm(request):

# 第一种：values-----获取的内部是字典,拿固定列数

# 1.1 正向查找： 使用ManyToManyField字段名user_info结合双下划线查询

models.UserGroup.objects.filter(group_name='group_python').values('group_name',

'user_info__username')

# 1.2 反向查找： 使用ManyToManyField的related_query_name='m2m',的字段

models.UserInfo.objects.filter(username='zhangsan').values('username',

'm2m__group_name')

# 第二种：values_list-----获取的是元组 拿固定列数

# 2.1 正向查找： 使用ManyToManyField字段名user_info结合双下划线查询

models.UserGroup.objects.filter(group_name='group_python').values_list('group_na

me', 'user_info__username')

# 2.2 反向查找： 使用ManyToManyField的related_query_name='m2m',的字段

lesson =

models.UserInfo.objects.filter(username='zhangsan').values_list('username',

'm2m__group_name')

# 自动创建UserInfo表和UserGroup表中的数据

'''

# user_info_obj = models.UserInfo.objects.get(username='lisi')

# user_info_objs = models.UserInfo.objects.all()

#

# group_obj = models.UserGroup.objects.get(group_name='group_python')

# group_objs = models.UserGroup.objects.all()

# group_obj.user_info.add(*user_info_objs)

# user_info_obj.usergroup_set.add(*group_objs)

user_list = [{'username':'zhangsan'},

{'username':'lisi'},

{'username':'wangwu'},]

group_list = [{'group_name':'group_python'},

{'group_name':'group_linux'},

{'group_name':'group_mysql'},]

for c in user_list:

models.UserInfo.objects.create(**c)

for l in group_list:

models.UserGroup.objects.create(**l)

'''

return HttpResponse('orm')

3.3 创建m2m多对多时ManyToManyField可以添加的参数

1、to, # 要进行关联的表名

2、related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】如： obj.

表名_set.all()

3、related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】

4.一大波model操作

4.1基础语句查询

class UserInfo(models.Model):

    username=models.CharField(max_length=32)

    password=models.CharField(max_length=32)

def orms(request):

    #创建

    第一种创建数据方法

    UserInfo.objects.create(username='zhangsan',password='123456')

    第二种创建数据方法

    obj=UserInfo(username='wangwu',password='123456')

    obj.save()

    第三种创建数据方法

    dic={'username':'liu','password':'123456'}

    UserInfo.objects.create(**dic)

    查

    查询所有数据

    result=UserInfo.objects.all()

    print(result)

    result=UserInfo.objects.filter(username='zhangsan',password='123456')

    for row in result:

        print(row.id,row.username,row.password)

    1 zhangsan 123456

    3 zhangsan 123456

    删

    UserInfo.objects.all().delete()  #删除全部数据

    UserInfo.objects.filter(username='zhangsan').delete()  #删除指定

    改

    UserInfo.objects.all().update(password='12345')

    UserInfo.objects.filter(id=4).update(password='15')

    获取个数

    num=UserInfo.objects.filter(username='wangwu').count()

    print(num)

    3

    执行原生sql

    new=UserInfo.objects.raw('select * from user_info')

    如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名

    指定数据库

    models.UserInfo.objects.raw('select * from userinfo', using="default")

    每访问一次数据库中zhangsan的年纪就会自动增加1

    UserInfo.objects.filter(name='wangwu').update(age=F('age')+1)

    return HttpResponse('yes')

进阶操作：牛掰掰的双下划线

1.大于

# models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值

# models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值

# models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值

# models.Tb1.objects.filter(id__lte=10) # 获取id小于等于10的 值

# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于 10的值

2.in

# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据

# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in

3.isnull

# Entry.objects.filter(pub_date__isnull=True) #双下划线isnull，查找

pub_date是null的数据

4、contains #就是原生sql的like操

作:模糊匹配

# models.Tb1.objects.filter(name__contains="ven")

# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏

感

# models.Tb1.objects.exclude(name__icontains="ven")

5.range

# models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and

6.order by

# models.Tb1.objects.filter(name='seven').order_by('id') # asc

没有减号升续排列

# models.Tb1.objects.filter(name='seven').order_by('-id') # desc

有减号升续排列

7.group by

# from django.db.models import Count, Min, Max, Sum

# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))

#根据id列进行分组

# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM

"app01_tb1"

# WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

8.limit offset  #分页

models.Tb1.objects.all[10:20]

9.regex正则匹配，iregex 不区分大小写

# Entry.objects.get(title__regex=r'^(An?|The) +')

# Entry.objects.get(title__iregex=r'^(an?|the) +')

10.date

#Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))

#__data表示日期查找，2005-01-01

# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

# 2005-01-01以后创建的数据

11、year

# Entry.objects.filter(pub_date__year=2005)

#__year根据年查找

# Entry.objects.filter(pub_date__year__gte=2005)

12、month

# Entry.objects.filter(pub_date__month=12)

# Entry.objects.filter(pub_date__month__gte=6)

13、day

# Entry.objects.filter(pub_date__day=3)

# Entry.objects.filter(pub_date__day__gte=3)

14、week_day

# Entry.objects.filter(pub_date__week_day=2)

# Entry.objects.filter(pub_date__week_day__gte=2)

15、hour

# Event.objects.filter(timestamp__hour=23)

# Event.objects.filter(time__hour=5)

# Event.objects.filter(timestamp__hour__gte=12)

16、minute

# Event.objects.filter(timestamp__minute=29)

# Event.objects.filter(time__minute=46)

# Event.objects.filter(timestamp__minute__gte=29)

17、second

# Event.objects.filter(timestamp__second=31)

# Event.objects.filter(time__second=2)

# Event.objects.filter(timestamp__second__gte=31)

4.3时间查询

from django.utils import timezone

from report.models import *

now = timezone.now()

# start_time = now - timezone.timedelta(days=7)

start_time = now - timezone.timedelta(hours=240) # 查询10天前的数据

end_time = now

qs = AllClarm.objects.filter(start_tm__range=(start_time, end_time))

5.F()和Q()查询语句

5.1F() ---- 专门取对象中某列值的操作

作用：F()允许Django在未实际链接数据的情况下具有对数据库字段的值的引用

from django.shortcuts import HttpResponse

from app01 import models

from django.db.models import F,Q

def orm(request):

# 每访问一次数据库中zhangsan的年纪就会自动增加1

models.Student.objects.filter(name='zhangsan').update(age=F("age") + 1)

# 自动生成Student表中数据

'''

stu_list = [{'name':'zhangsan','age':11},

{'name': 'lisi', 'age': 22},

{'name': 'wangwu', 'age': 33},]

for u in stu_list:

models.Student.objects.create(**u)

'''

return HttpResponse('orm')

5.2Q() ---- 复杂查询（用法1）

1、Q对象( django.db.models.Q )可以对关键字参数进行封装，从而更好地应用多个查询

2、可以组合使用 &（and）,|（or），~（not）操作符，当一个操作符用于两个Q的对象,它产生一个新的Q对象

3、如： Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')

from django.shortcuts import HttpResponse

from app01 import models

from django.db.models import F,Q

def orm(request):

# 查找学生表中年级大于1小于30姓zhang的所有学生

stus = models.Student.objects.filter(

Q(age__gt=1) & Q(age__lt=30),

Q(name__startswith='zhang')

)

print('stu',stus) #运行结果：[<Student: zhangsan>]

# 自动生成Student表中数据

'''

stu_list = [{'name':'zhangsan','age':11},

{'name': 'lisi', 'age': 22},

{'name': 'wangwu', 'age': 33},]

for u in stu_list:

models.Student.objects.create(**u)

'''

return HttpResponse('orm')

6.aggregate和annotate聚合函数 : 求平均值、 最大值、最小值等

6.1aggregate聚合函数

作用：从数据库中取出一个汇总的集合

from django.db.models import Count,Avg,Max,Sum

def orm(request):

stus = models.Student.objects.aggregate(

stu_num=Count('age'), #计算学生表中有多少条age条目

stu_avg=Avg('age'), #计算学生的平均年纪

stu_max=Max('age'), #找到年纪最大的学生

stu_sum=Sum('age')) #将表中的所有年纪相加

print('stu',stus)

return HttpResponse('ok')

#运行结果：{'stu_sum': 69, 'stu_max': 24, 'stu_avg': 23.0, 'stu_num': 3}

6.2 annotate实现聚合group by查询

作用：对查询结果进行分组，比如分组求出各年龄段的人数

注： annotate后面加filter过滤相当于原生sql语句中的having

from django.db.models import Count, Avg, Max, Min, Sum

def orm(request):

#1 按年纪分组查找学生表中各个年龄段学生人数：（22岁两人，24岁一人）

# 查询结果：[{'stu_num': 2, 'age': 22}, {'stu_num': 1, 'age': 24}]

stus1 = models.Student.objects.values('age').annotate(stu_num=Count('age'))

#2 按年纪分组查找学生表中各个年龄段学生人数，并过滤出年纪大于22的：

# 查询结果：[{'stu_num': 1, 'age': 24}] （年级大于22岁的仅一人，年级为24岁）

stus2 =

models.Student.objects.values('age').annotate(stu_num=Count('age')).filter(age__g

t=22)

#3 先按年纪分组，然后查询出各个年龄段学生的平均成绩

# 查询结果：[{'stu_Avg': 86.5, 'age': 22}, {'stu_Avg': 99.0, 'age': 24}]

# 22岁平均成绩：86.5 24岁平均成绩：99

stus3 = models.Student.objects.values('age').annotate(stu_Avg=Avg('grade'))

return HttpResponse('ok')

model基础操作的更多相关文章

  1. Django Model基础操作

    关于设计django model django为我们集成了ORM对数据库进行操作,我们只需要进行定义model,django就会自动为我们创建表,以及表之间的关联关系 创建好一个django项目-首先 ...

  2. model基础操作（下）

    3.Django多对多表结构操作   3.1 第一种: ManyToManyField   自己不创建第三张关系表,有m2m字段: 根据queryset对象增删改查(推荐)   from django ...

  3. model基础操作（上）

    1.创建表   https://www.cnblogs.com/xiaonq/p/7978409.html   1.1 Meta源信息   from django.db import models c ...

  4. numpy 基础操作

    Numpy 基础操作¶ 以numpy的基本数据例子来学习numpy基本数据处理方法 主要内容有: 创建数组 数组维度转换 数据选区和切片 数组数据计算 随机数 数据合并 数据统计计算 In [1]: ...

  5. python基础操作以及hdfs操作

    目录 前言 基础操作 hdfs操作 总结 一.前言        作为一个全栈工程师,必须要熟练掌握各种语言...HelloWorld.最近就被"逼着"走向了python开发之路, ...

  6. MYSQL基础操作

    MYSQL基础操作 [TOC] 1.基本定义 1.1.关系型数据库系统 关系型数据库系统是建立在关系模型上的数据库系统 什么是关系模型呢? 1.数据结构可以规定,同类数据结构一致,就是一个二维的表格 ...

  7. 【Learning Python】【第二章】Python基础类型和基础操作

    基础类型: 整型: py 3.0解决了整数溢出的问题,意味着整型不必考虑32位,64位,有无符号等问题,你写一个1亿亿亿,就是1亿亿亿,不会溢出 a = 10 ** 240 print(a) 执行以上 ...

  8. Emacs学习心得之 基础操作

    作者:枫雪庭 出处:http://www.cnblogs.com/FengXueTing-px/ 欢迎转载 Emacs学习心得之 基础操作 1.前言与学习计划2.Emacs基础操作 一. 前言与学习计 ...

  9. Git基础操作

    配置秘钥 1.检查本机有没有秘钥 检查~/.ssh看看是否有名为d_rsa.pub和id_dsa.pub的2个文件. $ ~/.sshbash: /c/Users/lenovo/.ssh: Is a ...

随机推荐

  1. 这个蒟蒻也开通wordpress博客啦~

    RT,欢迎各位dalao常来菜鸡博客玩,加友链什么的最好了~ 传送门(请注意https不能漏,因为本菜鸡的家用宽带只有443端口). 以后博客园的博客会同步更新. 这个人太颓了,只打算在wordpre ...

  2. Java基础系列-单例的7种写法

    原创文章,转载请标注出处:https://www.cnblogs.com/V1haoge/p/10755322.html 一.概述 Java中单例有7种写法,这个是在面试中经常被问到的内容,而且有时候 ...

  3. python开发基础(二)运算符以及数据类型之tuple(元组)

    # encoding: utf-8 # module builtins # from (built-in) # by generator 1.147 """ Built- ...

  4. 微服务网关Zuul和Gateway的区别

    spring-cloud-Gateway是spring-cloud的一个子项目.而zuul则是netflix公司的项目,只是spring将zuul集成在spring-cloud中使用而已.因为zuul ...

  5. 浅谈OpenGL之DSA

    今天准备写一篇文章简单介绍一下OpenGL4.5引入的一个新的扩展ARB_direct_state_access,这个扩展为OpenGL引入了一个新的特性就是Direct State Acess,下文 ...

  6. delphi key解密转c# 解决string 不可变长度问题

    遇见问题: delphi的解密需要在c#里面实现 方法一:delphi编写delphi dll组件,c#里面调用 方法二:c#重写delphi的代码进行解析 方法一: delphi部分代码: libr ...

  7. leetcode128-generate-parentheses

    题目描述 给出n对括号,请编写一个函数来生成所有的由n对括号组成的合法组合. 例如,给出n=3,解集为: "((()))", "(()())", "( ...

  8. Python图书管理系统

    图书管理系统 功能简介 添加图书时,图书ID不能重复,图书名可重复 删除,查询,修改功能,输入图书名之后提供所有的同名的图书,用户可以按照图书序号对具体的一本书进行操作 显示书籍,分行显示,每行一本书 ...

  9. 学习.NET 挑战赛

    今天访问dot.net 网站看到了一个学习.NET 挑战赛,发现已经赛程过半了,这是一个为那些想更多地了解 C# 和 .NET 的人举办的一个完全免费的课程活动,这些模块必须在 11 月底前完成.参加 ...

  10. 判断机器是big-endian、little-endian

    联合体union和大小端(big-endian.little-endian):下边示范了一种用途,代表四个含义的四个变量,但是可以用一个int来操作,直接int赋值,无论内存访问(指针大小的整数倍,访 ...